🚀 리플렉션, 이게 뭔데 이렇게 신기해?

친구야, 프로그램이 실행되는 동안 자기 자신의 코드를 들여다볼 수 있다면 어떨까? 🤔
마치 거울을 보듯이 자신의 구조를 파악하고, 심지어 그걸 바꿀 수도 있다면?
바로 그게 리플렉션(Reflection)이야!

C#에서 리플렉션은 프로그램이 실행 중에 자신의 메타데이터를 검사하고 조작할 수 있게 해주는 강력한 기능이야.
쉽게 말하면, 코드가 코드를 읽고 분석하는 거지. 😎
컴파일 타임에는 몰랐던 타입 정보를 런타임에 알아낼 수 있고,
심지어 동적으로 메서드를 호출하거나 객체를 생성할 수도 있어!

🔍 메타데이터란 무엇인가?

메타데이터는 "데이터에 대한 데이터"야. 🎪
C#에서는 어셈블리(Assembly)에 포함된 타입, 메서드, 프로퍼티, 어트리뷰트 등의 정보를 말해.
컴파일러가 코드를 컴파일할 때 이 메타데이터를 자동으로 생성해서 어셈블리에 함께 저장하지.

예를 들어, 너가 class Person이라는 클래스를 만들면,
컴파일러는 "Person이라는 클래스가 있고, 이 클래스에는 Name이라는 프로퍼티가 있고,
GetAge()라는 메서드가 있다"는 정보를 메타데이터로 저장해.
리플렉션은 바로 이 메타데이터를 읽어서 활용하는 거야! 📚

⚙️ System.Reflection 네임스페이스 파헤치기

C#에서 리플렉션을 사용하려면 System.Reflection 네임스페이스를 알아야 해.
여기에는 리플렉션 작업에 필요한 핵심 클래스들이 모여 있어! 🛠️

💻 기본 리플렉션 사용법 - Type 객체 얻기

리플렉션의 시작은 Type 객체를 얻는 것부터야! 🎬
Type 객체를 얻는 방법은 크게 세 가지가 있어:

1️⃣ typeof 연산자 사용 (컴파일 타임에 타입을 알 때)

Type type1 = typeof(string);
Type type2 = typeof(List<int>);
Type type3 = typeof(MyCustomClass);

Console.WriteLine(type1.Name);  // String
Console.WriteLine(type1.FullName);  // System.String
Console.WriteLine(type1.Namespace);  // System

2️⃣ GetType() 메서드 사용 (객체 인스턴스가 있을 때)

string text = "Hello, Reflection!";
Type type = text.GetType();

int number = 42;
Type numType = number.GetType();

Console.WriteLine(type.Name);  // String
Console.WriteLine(numType.Name);  // Int32

3️⃣ Type.GetType() 메서드 사용 (문자열로 타입 이름을 알 때)

// 정규화된 타입 이름 사용
Type type1 = Type.GetType("System.String");
Type type2 = Type.GetType("System.Collections.Generic.List`1");

// 같은 어셈블리 내의 타입
Type type3 = Type.GetType("MyNamespace.MyClass");

if (type1 != null)
{
    Console.WriteLine($"타입을 찾았어요: {type1.FullName}");
}

🔎 타입 정보 탐색하기

Type 객체를 얻었다면, 이제 그 타입에 대한 온갖 정보를 캐낼 수 있어! 🕵️
실제로 사용할 수 있는 예제를 한번 볼까?

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    private string _secret = "비밀이야!";
    
    public Person() { }
    
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
    
    public void SayHello()
    {
        Console.WriteLine($"안녕! 나는 {Name}이야!");
    }
    
    private void SecretMethod()
    {
        Console.WriteLine("이건 비밀 메서드!");
    }
}

// 리플렉션으로 Person 클래스 분석하기
Type personType = typeof(Person);

Console.WriteLine($"📌 타입 이름: {personType.Name}");
Console.WriteLine($"📌 전체 이름: {personType.FullName}");
Console.WriteLine($"📌 네임스페이스: {personType.Namespace}");
Console.WriteLine($"📌 클래스인가? {personType.IsClass}");
Console.WriteLine($"📌 추상 클래스인가? {personType.IsAbstract}");
Console.WriteLine($"📌 봉인(sealed)되었나? {personType.IsSealed}");

// 프로퍼티 정보 가져오기
Console.WriteLine("\n🔍 프로퍼티 목록:");
PropertyInfo[] properties = personType.GetProperties();
foreach (var prop in properties)
{
    Console.WriteLine($"  - {prop.Name} ({prop.PropertyType.Name})");
    Console.WriteLine($"    읽기 가능: {prop.CanRead}, 쓰기 가능: {prop.CanWrite}");
}

// 메서드 정보 가져오기
Console.WriteLine("\n🔍 메서드 목록:");
MethodInfo[] methods = personType.GetMethods(
    BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
foreach (var method in methods)
{
    Console.WriteLine($"  - {method.Name}");
    Console.WriteLine($"    반환 타입: {method.ReturnType.Name}");
    
    ParameterInfo[] parameters = method.GetParameters();
    if (parameters.Length > 0)
    {
        Console.WriteLine("    매개변수:");
        foreach (var param in parameters)
        {
            Console.WriteLine($"      • {param.Name} ({param.ParameterType.Name})");
        }
    }
}

// 생성자 정보 가져오기
Console.WriteLine("\n🔍 생성자 목록:");
ConstructorInfo[] constructors = personType.GetConstructors();
foreach (var ctor in constructors)
{
    ParameterInfo[] parameters = ctor.GetParameters();
    Console.WriteLine($"  - 매개변수 개수: {parameters.Length}");
    foreach (var param in parameters)
    {
        Console.WriteLine($"    • {param.Name} ({param.ParameterType.Name})");
    }
}

이 코드를 실행하면 Person 클래스의 모든 구조를 런타임에 파악할 수 있어! 😲
마치 X-ray로 클래스 내부를 들여다보는 것 같지?

🎯 BindingFlags - 검색 범위 지정하기

리플렉션으로 멤버를 검색할 때 BindingFlags를 사용하면
어떤 멤버를 찾을지 세밀하게 제어할 수 있어! 🎛️

Type type = typeof(Person);

// public 인스턴스 멤버만
var publicMembers = type.GetMembers(BindingFlags.Public | BindingFlags.Instance);

// private 인스턴스 필드만
var privateFields = type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance);

// 모든 메서드 (public + private, instance + static)
var allMethods = type.GetMethods(
    BindingFlags.Public | BindingFlags.NonPublic | 
    BindingFlags.Instance | BindingFlags.Static);

// 특정 이름의 메서드 찾기 (대소문자 무시)
var method = type.GetMethod("sayhello", 
    BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);

Console.WriteLine($"찾은 메서드: {method?.Name}");

🚀 동적으로 객체 생성하기

리플렉션의 진짜 매력은 런타임에 객체를 생성할 수 있다는 거야! 🎨
컴파일 타임에는 어떤 타입인지 몰라도, 실행 중에 동적으로 인스턴스를 만들 수 있지.

방법 1: Activator.CreateInstance 사용 (가장 간단)

// 기본 생성자로 객체 생성
Type type = typeof(Person);
object instance = Activator.CreateInstance(type);

// 제네릭 버전 (타입 캐스팅 불필요)
Person person = Activator.CreateInstance<Person>();

// 매개변수가 있는 생성자 사용
object instance2 = Activator.CreateInstance(type, "홍길동", 25);
Person person2 = (Person)instance2;

person2.SayHello();  // "안녕! 나는 홍길동이야!"

방법 2: ConstructorInfo 사용 (더 세밀한 제어)

Type type = typeof(Person);

// 특정 생성자 찾기
ConstructorInfo constructor = type.GetConstructor(
    new Type[] { typeof(string), typeof(int) });

if (constructor != null)
{
    // 생성자 호출
    object instance = constructor.Invoke(new object[] { "이순신", 30 });
    Person person = (Person)instance;
    
    person.SayHello();  // "안녕! 나는 이순신이야!"
}

// 기본 생성자 찾기
ConstructorInfo defaultCtor = type.GetConstructor(Type.EmptyTypes);
object instance2 = defaultCtor?.Invoke(null);

방법 3: FormatterServices (권장하지 않음, 특수한 경우만)

using System.Runtime.Serialization;

// 생성자를 호출하지 않고 객체 생성 (초기화되지 않은 상태)
Type type = typeof(Person);
object instance = FormatterServices.GetUninitializedObject(type);

// 주의: 생성자가 실행되지 않으므로 필드가 초기화되지 않음!
// 직렬화 프레임워크 등 특수한 경우에만 사용

🎪 동적으로 메서드 호출하기

객체를 만들었으니 이제 메서드를 호출해볼까? 😎
리플렉션을 사용하면 메서드 이름만 알면 동적으로 실행할 수 있어!

Person person = new Person("김철수", 28);
Type type = person.GetType();

// 메서드 찾기
MethodInfo method = type.GetMethod("SayHello");

if (method != null)
{
    // 메서드 호출 (매개변수 없음)
    method.Invoke(person, null);
    // 출력: "안녕! 나는 김철수야!"
}

// 매개변수가 있는 메서드 호출 예제
public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
    
    public double Multiply(double x, double y)
    {
        return x * y;
    }
}

Calculator calc = new Calculator();
Type calcType = calc.GetType();

// Add 메서드 호출
MethodInfo addMethod = calcType.GetMethod("Add");
object result = addMethod.Invoke(calc, new object[] { 10, 20 });
Console.WriteLine($"10 + 20 = {result}");  // 30

// Multiply 메서드 호출
MethodInfo multiplyMethod = calcType.GetMethod("Multiply");
object result2 = multiplyMethod.Invoke(calc, new object[] { 3.5, 2.0 });
Console.WriteLine($"3.5 × 2.0 = {result2}");  // 7.0

private 메서드도 호출할 수 있어! 🔓

Type type = typeof(Person);
Person person = new Person("비밀요원", 35);

// private 메서드 찾기
MethodInfo secretMethod = type.GetMethod("SecretMethod", 
    BindingFlags.NonPublic | BindingFlags.Instance);

if (secretMethod != null)
{
    // private 메서드 호출!
    secretMethod.Invoke(person, null);
    // 출력: "이건 비밀 메서드!"
}

// 이렇게 하면 일반적으로는 접근할 수 없는 private 멤버에도 접근 가능!
// 하지만 캡슐화를 깨뜨리는 거니까 정말 필요한 경우에만 사용해야 해.

제네릭 메서드 호출하기 🎯

public class GenericClass
{
    public T CreateInstance<T>() where T : new()
    {
        return new T();
    }
    
    public List<T> CreateList<T>(params T[] items)
    {
        return new List<T>(items);
    }
}

GenericClass obj = new GenericClass();
Type type = obj.GetType();

// 제네릭 메서드 찾기
MethodInfo method = type.GetMethod("CreateList");

// 타입 인자 지정 (MakeGenericMethod)
MethodInfo genericMethod = method.MakeGenericMethod(typeof(string));

// 호출
object result = genericMethod.Invoke(obj, new object[] { 
    new string[] { "사과", "바나나", "체리" } 
});

List<string> fruits = (List<string>)result;
Console.WriteLine($"과일 개수: {fruits.Count}");  // 3

📦 프로퍼티와 필드 값 읽고 쓰기

리플렉션으로 객체의 프로퍼티나 필드 값을 동적으로 읽고 쓸 수 있어! 📝
이건 특히 직렬화나 데이터 바인딩할 때 엄청 유용해.

Person person = new Person("박영희", 32);
Type type = person.GetType();

// 프로퍼티 값 읽기
PropertyInfo nameProp = type.GetProperty("Name");
object nameValue = nameProp.GetValue(person);
Console.WriteLine($"이름: {nameValue}");  // "박영희"

PropertyInfo ageProp = type.GetProperty("Age");
object ageValue = ageProp.GetValue(person);
Console.WriteLine($"나이: {ageValue}");  // 32

// 프로퍼티 값 쓰기
nameProp.SetValue(person, "최민수");
ageProp.SetValue(person, 40);

Console.WriteLine($"변경된 이름: {person.Name}");  // "최민수"
Console.WriteLine($"변경된 나이: {person.Age}");  // 40

// 모든 프로퍼티 순회하면서 값 출력
Console.WriteLine("\n📋 모든 프로퍼티 값:");
foreach (PropertyInfo prop in type.GetProperties())
{
    object value = prop.GetValue(person);
    Console.WriteLine($"{prop.Name}: {value}");
}

private 필드 접근하기 🕵️

Type type = typeof(Person);
Person person = new Person("스파이", 28);

// private 필드 찾기
FieldInfo secretField = type.GetField("_secret", 
    BindingFlags.NonPublic | BindingFlags.Instance);

if (secretField != null)
{
    // private 필드 값 읽기
    object secretValue = secretField.GetValue(person);
    Console.WriteLine($"비밀 정보: {secretValue}");  // "비밀이야!"
    
    // private 필드 값 변경
    secretField.SetValue(person, "이제 비밀이 아니야!");
    
    object newValue = secretField.GetValue(person);
    Console.WriteLine($"변경된 비밀: {newValue}");  // "이제 비밀이 아니야!"
}

인덱서 프로퍼티 다루기 📊

public class DataCollection
{
    private Dictionary<string, object> _data = new Dictionary<string, object>();
    
    public object this[string key]
    {
        get { return _data.ContainsKey(key) ? _data[key] : null; }
        set { _data[key] = value; }
    }
}

DataCollection collection = new DataCollection();
Type type = collection.GetType();

// 인덱서 프로퍼티 찾기 (이름은 "Item")
PropertyInfo indexer = type.GetProperty("Item");

// 인덱서로 값 설정
indexer.SetValue(collection, "안녕하세요!", new object[] { "greeting" });

// 인덱서로 값 읽기
object value = indexer.GetValue(collection, new object[] { "greeting" });
Console.WriteLine(value);  // "안녕하세요!"

🏷️ 어트리뷰트(Attribute) 활용하기

어트리뷰트는 코드에 메타데이터를 추가하는 방법이야! 🎨
리플렉션과 함께 사용하면 정말 강력한 기능을 만들 수 있어.
예를 들어, 재능넷 같은 플랫폼에서 API 엔드포인트를 자동으로 생성하거나,
유효성 검사를 자동화하는 데 사용할 수 있지! 💪

커스텀 어트리뷰트 만들기

// 유효성 검사용 어트리뷰트
[AttributeUsage(AttributeTargets.Property)]
public class RequiredAttribute : Attribute
{
    public string ErrorMessage { get; set; }
    
    public RequiredAttribute(string errorMessage = "필수 항목입니다.")
    {
        ErrorMessage = errorMessage;
    }
}

[AttributeUsage(AttributeTargets.Property)]
public class RangeAttribute : Attribute
{
    public int Min { get; set; }
    public int Max { get; set; }
    public string ErrorMessage { get; set; }
    
    public RangeAttribute(int min, int max)
    {
        Min = min;
        Max = max;
        ErrorMessage = $"값은 {min}에서 {max} 사이여야 합니다.";
    }
}

// 어트리뷰트 사용
public class UserRegistration
{
    [Required("사용자 이름은 필수입니다!")]
    public string Username { get; set; }
    
    [Required]
    public string Email { get; set; }
    
    [Range(18, 100)]
    public int Age { get; set; }
    
    public string PhoneNumber { get; set; }  // 선택 사항
}

리플렉션으로 어트리뷰트 읽고 유효성 검사하기 ✅

public class Validator
{
    public static List<string> Validate(object obj)
    {
        List<string> errors = new List<string>();
        Type type = obj.GetType();
        
        foreach (PropertyInfo prop in type.GetProperties())
        {
            // Required 어트리뷰트 확인
            var requiredAttr = prop.GetCustomAttribute<RequiredAttribute>();
            if (requiredAttr != null)
            {
                object value = prop.GetValue(obj);
                if (value == null || string.IsNullOrWhiteSpace(value.ToString()))
                {
                    errors.Add($"{prop.Name}: {requiredAttr.ErrorMessage}");
                }
            }
            
            // Range 어트리뷰트 확인
            var rangeAttr = prop.GetCustomAttribute<RangeAttribute>();
            if (rangeAttr != null)
            {
                object value = prop.GetValue(obj);
                if (value is int intValue)
                {
                    if (intValue < rangeAttr.Min || intValue > rangeAttr.Max)
                    {
                        errors.Add($"{prop.Name}: {rangeAttr.ErrorMessage}");
                    }
                }
            }
        }
        
        return errors;
    }
}

// 사용 예제
UserRegistration user = new UserRegistration
{
    Username = "",  // 비어있음 - 에러!
    Email = "test@example.com",
    Age = 15  // 범위 밖 - 에러!
};

List<string> errors = Validator.Validate(user);

if (errors.Count > 0)
{
    Console.WriteLine("❌ 유효성 검사 실패:");
    foreach (string error in errors)
    {
        Console.WriteLine($"  • {error}");
    }
}
else
{
    Console.WriteLine("✅ 유효성 검사 통과!");
}

// 출력:
// ❌ 유효성 검사 실패:
//   • Username: 사용자 이름은 필수입니다!
//   • Age: 값은 18에서 100 사이여야 합니다.

여러 어트리뷰트 한 번에 가져오기 🎯

[Serializable]
[Obsolete("이 클래스는 더 이상 사용되지 않습니다. NewPerson을 사용하세요.")]
public class OldPerson
{
    public string Name { get; set; }
}

Type type = typeof(OldPerson);

// 모든 어트리뷰트 가져오기
object[] attributes = type.GetCustomAttributes(false);

Console.WriteLine($"어트리뷰트 개수: {attributes.Length}");

foreach (var attr in attributes)
{
    Console.WriteLine($"  • {attr.GetType().Name}");
    
    if (attr is ObsoleteAttribute obsolete)
    {
        Console.WriteLine($"    메시지: {obsolete.Message}");
    }
}

// 특정 어트리뷰트만 확인
bool isSerializable = type.IsDefined(typeof(SerializableAttribute), false);
Console.WriteLine($"직렬화 가능? {isSerializable}");  // True

🔧 Assembly 다루기 - DLL 동적 로딩

Assembly는 .NET의 배포 단위야. DLL이나 EXE 파일이지! 📦
리플렉션을 사용하면 런타임에 어셈블리를 로드하고 그 안의 타입을 사용할 수 있어.
플러그인 시스템을 만들 때 필수적인 기술이야! 🔌

// 현재 실행 중인 어셈블리 가져오기
Assembly currentAssembly = Assembly.GetExecutingAssembly();
Console.WriteLine($"현재 어셈블리: {currentAssembly.FullName}");

// 특정 타입이 속한 어셈블리 가져오기
Assembly stringAssembly = typeof(string).Assembly;
Console.WriteLine($"String이 속한 어셈블리: {stringAssembly.GetName().Name}");

// 어셈블리에서 모든 타입 가져오기
Type[] types = currentAssembly.GetTypes();
Console.WriteLine($"\n📚 어셈블리 내 타입 개수: {types.Length}");

foreach (Type type in types.Take(10))  // 처음 10개만
{
    Console.WriteLine($"  • {type.FullName}");
}

// 특정 조건의 타입만 필터링
var publicClasses = types.Where(t => t.IsClass && t.IsPublic);
Console.WriteLine($"\n공개 클래스 개수: {publicClasses.Count()}");

// 특정 인터페이스를 구현한 타입 찾기
public interface IPlugin
{
    string Name { get; }
    void Execute();
}

var pluginTypes = types.Where(t => 
    typeof(IPlugin).IsAssignableFrom(t) && 
    !t.IsInterface && 
    !t.IsAbstract);

Console.WriteLine($"\n🔌 플러그인 타입 개수: {pluginTypes.Count()}");
foreach (var pluginType in pluginTypes)
{
    Console.WriteLine($"  • {pluginType.Name}");
}

외부 DLL 동적으로 로드하기 🚀

// 방법 1: 파일 경로로 로드
Assembly assembly = Assembly.LoadFrom(@"C:\Plugins\MyPlugin.dll");

// 방법 2: 어셈블리 이름으로 로드 (GAC나 앱 디렉토리에서 검색)
Assembly assembly2 = Assembly.Load("MyPlugin, Version=1.0.0.0, Culture=neutral");

// 방법 3: 바이트 배열로 로드 (메모리에서)
byte[] assemblyBytes = File.ReadAllBytes(@"C:\Plugins\MyPlugin.dll");
Assembly assembly3 = Assembly.Load(assemblyBytes);

// 로드된 어셈블리에서 타입 찾기
Type pluginType = assembly.GetType("MyPlugin.MainPlugin");

if (pluginType != null)
{
    // 플러그인 인스턴스 생성
    object plugin = Activator.CreateInstance(pluginType);
    
    // IPlugin 인터페이스로 캐스팅
    if (plugin is IPlugin iPlugin)
    {
        Console.WriteLine($"플러그인 이름: {iPlugin.Name}");
        iPlugin.Execute();
    }
}

// 어셈블리의 모든 리소스 나열
string[] resourceNames = assembly.GetManifestResourceNames();
Console.WriteLine("\n📄 임베디드 리소스:");
foreach (string name in resourceNames)
{
    Console.WriteLine($"  • {name}");
}

플러그인 시스템 구현 예제 🎮

public class PluginManager
{
    private List<IPlugin> _plugins = new List<IPlugin>();
    
    public void LoadPlugins(string pluginDirectory)
    {
        if (!Directory.Exists(pluginDirectory))
        {
            Console.WriteLine($"플러그인 디렉토리가 없습니다: {pluginDirectory}");
            return;
        }
        
        // 디렉토리의 모든 DLL 파일 검색
        string[] dllFiles = Directory.GetFiles(pluginDirectory, "*.dll");
        
        foreach (string dllFile in dllFiles)
        {
            try
            {
                // DLL 로드
                Assembly assembly = Assembly.LoadFrom(dllFile);
                
                // IPlugin을 구현한 타입 찾기
                var pluginTypes = assembly.GetTypes()
                    .Where(t => typeof(IPlugin).IsAssignableFrom(t) && 
                               !t.IsInterface && 
                               !t.IsAbstract);
                
                foreach (Type pluginType in pluginTypes)
                {
                    // 플러그인 인스턴스 생성
                    IPlugin plugin = (IPlugin)Activator.CreateInstance(pluginType);
                    _plugins.Add(plugin);
                    
                    Console.WriteLine($"✅ 플러그인 로드 성공: {plugin.Name}");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"❌ {Path.GetFileName(dllFile)} 로드 실패: {ex.Message}");
            }
        }
        
        Console.WriteLine($"\n총 {_plugins.Count}개의 플러그인이 로드되었습니다.");
    }
    
    public void ExecuteAllPlugins()
    {
        Console.WriteLine("\n🚀 모든 플러그인 실행:");
        foreach (var plugin in _plugins)
        {
            Console.WriteLine($"\n--- {plugin.Name} ---");
            plugin.Execute();
        }
    }
    
    public IPlugin GetPlugin(string name)
    {
        return _plugins.FirstOrDefault(p => 
            p.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
    }
}

// 사용 예제
PluginManager manager = new PluginManager();
manager.LoadPlugins(@"C:\MyApp\Plugins");
manager.ExecuteAllPlugins();

// 특정 플러그인만 실행
IPlugin specificPlugin = manager.GetPlugin("DataProcessor");
specificPlugin?.Execute();

⚡ 성능 최적화 - 리플렉션은 느려!

솔직히 말하면, 리플렉션은 느려. 😅
일반적인 메서드 호출보다 10배에서 100배까지 느릴 수 있어.
하지만 걱정 마! 최적화 방법이 있거든. 💪

최적화 방법 1: 캐싱 활용 💾

public class ReflectionCache
{
    private static Dictionary<string, MethodInfo> _methodCache 
        = new Dictionary<string, MethodInfo>();
    
    private static Dictionary<string, PropertyInfo> _propertyCache 
        = new Dictionary<string, PropertyInfo>();
    
    public static MethodInfo GetMethod(Type type, string methodName)
    {
        string key = $"{type.FullName}.{methodName}";
        
        if (!_methodCache.ContainsKey(key))
        {
            MethodInfo method = type.GetMethod(methodName);
            _methodCache[key] = method;
        }
        
        return _methodCache[key];
    }
    
    public static PropertyInfo GetProperty(Type type, string propertyName)
    {
        string key = $"{type.FullName}.{propertyName}";
        
        if (!_propertyCache.ContainsKey(key))
        {
            PropertyInfo property = type.GetProperty(propertyName);
            _propertyCache[key] = property;
        }
        
        return _propertyCache[key];
    }
}

// 사용 예제
Type type = typeof(Person);

// 첫 번째 호출: 리플렉션으로 검색 (느림)
MethodInfo method1 = ReflectionCache.GetMethod(type, "SayHello");

// 두 번째 호출: 캐시에서 가져옴 (빠름!)
MethodInfo method2 = ReflectionCache.GetMethod(type, "SayHello");

최적화 방법 2: Delegate 사용 🚀

// 리플렉션으로 메서드를 찾은 후 Delegate로 변환
public class FastInvoker
{
    private static Dictionary<string, Delegate> _delegateCache 
        = new Dictionary<string, Delegate>();
    
    public static Func<T, TResult> CreateGetter<T, TResult>(string propertyName)
    {
        string key = $"{typeof(T).FullName}.{propertyName}";
        
        if (!_delegateCache.ContainsKey(key))
        {
            PropertyInfo property = typeof(T).GetProperty(propertyName);
            MethodInfo getMethod = property.GetGetMethod();
            
            // Delegate 생성
            Func<T, TResult> getter = 
                (Func<T, TResult>)Delegate.CreateDelegate(
                    typeof(Func<T, TResult>), getMethod);
            
            _delegateCache[key] = getter;
        }
        
        return (Func<T, TResult>)_delegateCache[key];
    }
    
    public static Action<T, TValue> CreateSetter<T, TValue>(string propertyName)
    {
        string key = $"{typeof(T).FullName}.{propertyName}.Set";
        
        if (!_delegateCache.ContainsKey(key))
        {
            PropertyInfo property = typeof(T).GetProperty(propertyName);
            MethodInfo setMethod = property.GetSetMethod();
            
            Action<T, TValue> setter = 
                (Action<T, TValue>)Delegate.CreateDelegate(
                    typeof(Action<T, TValue>), setMethod);
            
            _delegateCache[key] = setter;
        }
        
        return (Action<T, TValue>)_delegateCache[key];
    }
}

// 사용 예제
Person person = new Person("테스트", 25);

// Getter 생성 (한 번만)
var nameGetter = FastInvoker.CreateGetter<Person, string>("Name");

// 이후 호출은 일반 메서드 호출만큼 빠름!
string name = nameGetter(person);  // 매우 빠름!

// Setter 생성
var nameSetter = FastInvoker.CreateSetter<Person, string>("Name");
nameSetter(person, "새 이름");  // 매우 빠름!

최적화 방법 3: Expression Tree 사용 🌳

using System.Linq.Expressions;

public class ExpressionHelper
{
    public static Func<T> CreateConstructor<T>() where T : new()
    {
        // Expression Tree로 생성자 호출 코드 생성
        NewExpression newExp = Expression.New(typeof(T));
        LambdaExpression lambda = Expression.Lambda<Func<T>>(newExp);
        
        // 컴파일해서 Delegate로 변환
        return (Func<T>)lambda.Compile();
    }
    
    public static Func<object> CreateConstructor(Type type)
    {
        NewExpression newExp = Expression.New(type);
        LambdaExpression lambda = Expression.Lambda<Func<object>>(
            Expression.Convert(newExp, typeof(object)));
        
        return (Func<object>)lambda.Compile();
    }
    
    public static Func<T, TProperty> CreatePropertyGetter<T, TProperty>(
        string propertyName)
    {
        ParameterExpression parameter = Expression.Parameter(typeof(T), "obj");
        MemberExpression property = Expression.Property(parameter, propertyName);
        LambdaExpression lambda = Expression.Lambda<Func<T, TProperty>>(
            property, parameter);
        
        return (Func<T, TProperty>)lambda.Compile();
    }
}

// 사용 예제
// 생성자 Delegate 생성
var personFactory = ExpressionHelper.CreateConstructor<Person>();

// 이제 객체 생성이 new Person()과 거의 같은 속도!
Person p1 = personFactory();
Person p2 = personFactory();
Person p3 = personFactory();

// 프로퍼티 Getter 생성
var ageGetter = ExpressionHelper.CreatePropertyGetter<Person, int>("Age");
int age = ageGetter(p1);  // 매우 빠름!

성능 비교 벤치마크 📊

using System.Diagnostics;

public class PerformanceTest
{
    public static void ComparePerformance()
    {
        Person person = new Person("테스트", 30);
        int iterations = 1000000;
        Stopwatch sw = new Stopwatch();
        
        // 1. 일반 호출
        sw.Start();
        for (int i = 0; i < iterations; i++)
        {
            string name = person.Name;
        }
        sw.Stop();
        Console.WriteLine($"일반 호출: {sw.ElapsedMilliseconds}ms");
        
        // 2. 리플렉션 (캐싱 없음)
        PropertyInfo prop = typeof(Person).GetProperty("Name");
        sw.Restart();
        for (int i = 0; i < iterations; i++)
        {
            object name = prop.GetValue(person);
        }
        sw.Stop();
        Console.WriteLine($"리플렉션 (캐싱 없음): {sw.ElapsedMilliseconds}ms");
        
        // 3. 리플렉션 (캐싱 있음)
        PropertyInfo cachedProp = ReflectionCache.GetProperty(typeof(Person), "Name");
        sw.Restart();
        for (int i = 0; i < iterations; i++)
        {
            object name = cachedProp.GetValue(person);
        }
        sw.Stop();
        Console.WriteLine($"리플렉션 (캐싱): {sw.ElapsedMilliseconds}ms");
        
        // 4. Delegate 사용
        var getter = FastInvoker.CreateGetter<Person, string>("Name");
        sw.Restart();
        for (int i = 0; i < iterations; i++)
        {
            string name = getter(person);
        }
        sw.Stop();
        Console.WriteLine($"Delegate: {sw.ElapsedMilliseconds}ms");
        
        // 5. Expression Tree
        var exprGetter = ExpressionHelper.CreatePropertyGetter<Person, string>("Name");
        sw.Restart();
        for (int i = 0; i < iterations; i++)
        {
            string name = exprGetter(person);
        }
        sw.Stop();
        Console.WriteLine($"Expression Tree: {sw.ElapsedMilliseconds}ms");
    }
}

// 실행 결과 예시:
// 일반 호출: 5ms
// 리플렉션 (캐싱 없음): 850ms
// 리플렉션 (캐싱): 720ms
// Delegate: 12ms
// Expression Tree: 8ms

🎨 실전 활용 예제 - JSON 직렬화 구현

이제 배운 걸 종합해서 간단한 JSON 직렬화 라이브러리를 만들어볼까? 🛠️
재능넷 같은 플랫폼에서 API 응답을 만들 때 유용하게 쓸 수 있어!

using System.Text;

public class SimpleJsonSerializer
{
    public static string Serialize(object obj)
    {
        if (obj == null)
            return "null";
        
        Type type = obj.GetType();
        
        // 기본 타입 처리
        if (type.IsPrimitive || type == typeof(string))
        {
            return SerializePrimitive(obj);
        }
        
        // 배열/리스트 처리
        if (obj is IEnumerable enumerable && type != typeof(string))
        {
            return SerializeEnumerable(enumerable);
        }
        
        // 객체 처리
        return SerializeObject(obj);
    }
    
    private static string SerializePrimitive(object obj)
    {
        if (obj is string str)
            return $"\"{str}\"";
        
        if (obj is bool b)
            return b.ToString().ToLower();
        
        return obj.ToString();
    }
    
    private static string SerializeEnumerable(IEnumerable enumerable)
    {
        StringBuilder sb = new StringBuilder();
        sb.Append("[");
        
        bool first = true;
        foreach (object item in enumerable)
        {
            if (!first)
                sb.Append(",");
            
            sb.Append(Serialize(item));
            first = false;
        }
        
        sb.Append("]");
        return sb.ToString();
    }
    
    private static string SerializeObject(object obj)
    {
        Type type = obj.GetType();
        PropertyInfo[] properties = type.GetProperties(
            BindingFlags.Public | BindingFlags.Instance);
        
        StringBuilder sb = new StringBuilder();
        sb.Append("{");
        
        bool first = true;
        foreach (PropertyInfo prop in properties)
        {
            // 읽기 가능한 프로퍼티만
            if (!prop.CanRead)
                continue;
            
            if (!first)
                sb.Append(",");
            
            string propName = prop.Name;
            object propValue = prop.GetValue(obj);
            
            sb.Append($"\"{propName}\":");
            sb.Append(Serialize(propValue));
            
            first = false;
        }
        
        sb.Append("}");
        return sb.ToString();
    }
}

// 사용 예제
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public bool InStock { get; set; }
    public List<string> Tags { get; set; }
}

Product product = new Product
{
    Id = 1,
    Name = "C# 프로그래밍 강의",
    Price = 50000,
    InStock = true,
    Tags = new List<string> { "프로그래밍", "C#", "초급" }
};

string json = SimpleJsonSerializer.Serialize(product);
Console.WriteLine(json);

// 출력:
// {"Id":1,"Name":"C# 프로그래밍 강의","Price":50000,"InStock":true,"Tags":["프로그래밍","C#","초급"]}

어트리뷰트로 직렬화 제어하기 🎛️

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

[AttributeUsage(AttributeTargets.Property)]
public class JsonPropertyAttribute : Attribute
{
    public string Name { get; set; }
    
    public JsonPropertyAttribute(string name)
    {
        Name = name;
    }
}

public class User
{
    public int Id { get; set; }
    
    [JsonProperty("username")]
    public string Name { get; set; }
    
    public string Email { get; set; }
    
    [JsonIgnore]
    public string Password { get; set; }  // 직렬화에서 제외
    
    [JsonProperty("is_active")]
    public bool IsActive { get; set; }
}

// SimpleJsonSerializer 개선
private static string SerializeObject(object obj)
{
    Type type = obj.GetType();
    PropertyInfo[] properties = type.GetProperties(
        BindingFlags.Public | BindingFlags.Instance);
    
    StringBuilder sb = new StringBuilder();
    sb.Append("{");
    
    bool first = true;
    foreach (PropertyInfo prop in properties)
    {
        if (!prop.CanRead)
            continue;
        
        // JsonIgnore 어트리뷰트 확인
        if (prop.GetCustomAttribute<JsonIgnoreAttribute>() != null)
            continue;
        
        if (!first)
            sb.Append(",");
        
        // JsonProperty 어트리뷰트로 이름 변경
        string propName = prop.Name;
        var jsonPropAttr = prop.GetCustomAttribute<JsonPropertyAttribute>();
        if (jsonPropAttr != null)
        {
            propName = jsonPropAttr.Name;
        }
        
        object propValue = prop.GetValue(obj);
        
        sb.Append($"\"{propName}\":");
        sb.Append(Serialize(propValue));
        
        first = false;
    }
    
    sb.Append("}");
    return sb.ToString();
}

// 사용
User user = new User
{
    Id = 100,
    Name = "홍길동",
    Email = "hong@example.com",
    Password = "secret123",  // 직렬화되지 않음
    IsActive = true
};

string json = SimpleJsonSerializer.Serialize(user);
Console.WriteLine(json);

// 출력:
// {"Id":100,"username":"홍길동","Email":"hong@example.com","is_active":true}

🔐 보안 고려사항

리플렉션은 강력하지만, 그만큼 위험할 수도 있어! 🚨
private 멤버에 접근할 수 있다는 건 캡슐화를 깨뜨릴 수 있다는 뜻이거든.

// ❌ 나쁜 예: 사용자 입력을 그대로 사용
public object InvokeMethod(string typeName, string methodName, object[] args)
{
    Type type = Type.GetType(typeName);  // 위험!
    MethodInfo method = type.GetMethod(methodName);  // 위험!
    return method.Invoke(null, args);
}

// ✅ 좋은 예: 화이트리스트 검증
public object InvokeMethod(string typeName, string methodName, object[] args)
{
    // 허용된 타입 목록
    var allowedTypes = new HashSet<string>
    {
        "MyApp.Calculator",
        "MyApp.StringHelper",
        "MyApp.DateHelper"
    };
    
    if (!allowedTypes.Contains(typeName))
    {
        throw new SecurityException($"타입 '{typeName}'은 허용되지 않습니다.");
    }
    
    Type type = Type.GetType(typeName);
    if (type == null)
    {
        throw new ArgumentException($"타입 '{typeName}'을 찾을 수 없습니다.");
    }
    
    // 허용된 메서드 목록
    var allowedMethods = new HashSet<string> { "Add", "Subtract", "Format" };
    
    if (!allowedMethods.Contains(methodName))
    {
        throw new SecurityException($"메서드 '{methodName}'은 허용되지 않습니다.");
    }
    
    MethodInfo method = type.GetMethod(methodName);
    if (method == null)
    {
        throw new ArgumentException($"메서드 '{methodName}'을 찾을 수 없습니다.");
    }
    
    try
    {
        return method.Invoke(null, args);
    }
    catch (TargetInvocationException ex)
    {
        // 실제 예외를 다시 던지기
        throw ex.InnerException ?? ex;
    }
}

// 안전한 프로퍼티 설정
public void SetPropertySafely<T>(T obj, string propertyName, object value)
{
    Type type = typeof(T);
    PropertyInfo property = type.GetProperty(propertyName);
    
    if (property == null)
    {
        throw new ArgumentException($"프로퍼티 '{propertyName}'이 존재하지 않습니다.");
    }
    
    if (!property.CanWrite)
    {
        throw new InvalidOperationException($"프로퍼티 '{propertyName}'은 읽기 전용입니다.");
    }
    
    // 타입 호환성 검사
    if (value != null && !property.PropertyType.IsAssignableFrom(value.GetType()))
    {
        throw new ArgumentException(
            $"값의 타입({value.GetType().Name})이 프로퍼티 타입({property.PropertyType.Name})과 호환되지 않습니다.");
    }
    
    try
    {
        property.SetValue(obj, value);
    }
    catch (Exception ex)
    {
        throw new InvalidOperationException(
            $"프로퍼티 '{propertyName}' 설정 중 오류 발생", ex);
    }
}

🌟 고급 기법 - 동적 타입 생성

리플렉션의 끝판왕! 런타임에 완전히 새로운 타입을 만들 수 있어! 🎭
System.Reflection.Emit 네임스페이스를 사용하면
IL(Intermediate Language) 코드를 직접 생성해서 새로운 클래스를 만들 수 있지.

using System.Reflection.Emit;

public class DynamicTypeBuilder
{
    public static Type CreateDynamicType(string typeName, 
        Dictionary<string, Type> properties)
    {
        // 동적 어셈블리 생성
        AssemblyName assemblyName = new AssemblyName("DynamicAssembly");
        AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(
            assemblyName, AssemblyBuilderAccess.Run);
        
        // 동적 모듈 생성
        ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("DynamicModule");
        
        // 동적 타입 생성
        TypeBuilder typeBuilder = moduleBuilder.DefineType(
            typeName,
            TypeAttributes.Public | TypeAttributes.Class);
        
        // 각 프로퍼티 추가
        foreach (var prop in properties)
        {
            AddProperty(typeBuilder, prop.Key, prop.Value);
        }
        
        // 타입 완성
        return typeBuilder.CreateType();
    }
    
    private static void AddProperty(TypeBuilder typeBuilder, 
        string propertyName, Type propertyType)
    {
        // private 필드 생성
        FieldBuilder fieldBuilder = typeBuilder.DefineField(
            "_" + propertyName.ToLower(),
            propertyType,
            FieldAttributes.Private);
        
        // public 프로퍼티 생성
        PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(
            propertyName,
            PropertyAttributes.HasDefault,
            propertyType,
            null);
        
        // Getter 메서드 생성
        MethodBuilder getterBuilder = typeBuilder.DefineMethod(
            "get_" + propertyName,
            MethodAttributes.Public | MethodAttributes.SpecialName | 
            MethodAttributes.HideBySig,
            propertyType,
            Type.EmptyTypes);
        
        ILGenerator getterIL = getterBuilder.GetILGenerator();
        getterIL.Emit(OpCodes.Ldarg_0);
        getterIL.Emit(OpCodes.Ldfld, fieldBuilder);
        getterIL.Emit(OpCodes.Ret);
        
        // Setter 메서드 생성
        MethodBuilder setterBuilder = typeBuilder.DefineMethod(
            "set_" + propertyName,
            MethodAttributes.Public | MethodAttributes.SpecialName | 
            MethodAttributes.HideBySig,
            null,
            new Type[] { propertyType });
        
        ILGenerator setterIL = setterBuilder.GetILGenerator();
        setterIL.Emit(OpCodes.Ldarg_0);
        setterIL.Emit(OpCodes.Ldarg_1);
        setterIL.Emit(OpCodes.Stfld, fieldBuilder);
        setterIL.Emit(OpCodes.Ret);
        
        // 프로퍼티에 getter/setter 연결
        propertyBuilder.SetGetMethod(getterBuilder);
        propertyBuilder.SetSetMethod(setterBuilder);
    }
}

// 사용 예제
var properties = new Dictionary<string, Type>
{
    { "Id", typeof(int) },
    { "Name", typeof(string) },
    { "CreatedDate", typeof(DateTime) },
    { "IsActive", typeof(bool) }
};

Type dynamicType = DynamicTypeBuilder.CreateDynamicType("DynamicEntity", properties);

// 동적 타입의 인스턴스 생성
object instance = Activator.CreateInstance(dynamicType);

// 프로퍼티 설정
PropertyInfo idProp = dynamicType.GetProperty("Id");
idProp.SetValue(instance, 123);

PropertyInfo nameProp = dynamicType.GetProperty("Name");
nameProp.SetValue(instance, "동적 객체");

PropertyInfo dateProp = dynamicType.GetProperty("CreatedDate");
dateProp.SetValue(instance, DateTime.Now);

// 프로퍼티 읽기
Console.WriteLine($"Id: {idProp.GetValue(instance)}");
Console.WriteLine($"Name: {nameProp.GetValue(instance)}");
Console.WriteLine($"CreatedDate: {dateProp.GetValue(instance)}");

이 기법은 ORM 프레임워크나 프록시 객체 생성에 사용돼.
Entity Framework 같은 라이브러리가 내부적으로 이런 방식을 사용하지! 🔥

🎓 실무 활용 시나리오

자, 이제 실제로 어떻게 활용하는지 몇 가지 시나리오를 볼까? 💼

시나리오 1: 설정 파일 자동 바인딩 ⚙️

public class ConfigurationBinder
{
    public static T Bind<T>(Dictionary<string, string> config) where T : new()
    {
        T instance = new T();
        Type type = typeof(T);
        
        foreach (var kvp in config)
        {
            PropertyInfo property = type.GetProperty(kvp.Key, 
                BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
            
            if (property != null && property.CanWrite)
            {
                try
                {
                    // 문자열을 프로퍼티 타입으로 변환
                    object value = Convert.ChangeType(kvp.Value, property.PropertyType);
                    property.SetValue(instance, value);
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"'{kvp.Key}' 바인딩 실패: {ex.Message}");
                }
            }
        }
        
        return instance;
    }
}

public class AppSettings
{
    public string DatabaseConnection { get; set; }
    public int MaxConnections { get; set; }
    public bool EnableLogging { get; set; }
    public double Timeout { get; set; }
}

// 사용
var configData = new Dictionary<string, string>
{
    { "DatabaseConnection", "Server=localhost;Database=MyDB" },
    { "MaxConnections", "100" },
    { "EnableLogging", "true" },
    { "Timeout", "30.5" }
};

AppSettings settings = ConfigurationBinder.Bind<AppSettings>(configData);

Console.WriteLine($"DB 연결: {settings.DatabaseConnection}");
Console.WriteLine($"최대 연결: {settings.MaxConnections}");
Console.WriteLine($"로깅 활성화: {settings.EnableLogging}");
Console.WriteLine($"타임아웃: {settings.Timeout}초");

시나리오 2: 간단한 의존성 주입 컨테이너 💉

public class SimpleContainer
{
    private Dictionary<Type, Type> _registrations = new Dictionary<Type, Type>();
    private Dictionary<Type, object> _singletons = new Dictionary<Type, object>();
    
    public void Register<TInterface, TImplementation>() 
        where TImplementation : TInterface
    {
        _registrations[typeof(TInterface)] = typeof(TImplementation);
    }
    
    public void RegisterSingleton<TInterface, TImplementation>() 
        where TImplementation : TInterface
    {
        Type interfaceType = typeof(TInterface);
        Type implementationType = typeof(TImplementation);
        
        _registrations[interfaceType] = implementationType;
        
        // 싱글톤 인스턴스 생성
        object instance = CreateInstance(implementationType);
        _singletons[interfaceType] = instance;
    }
    
    public T Resolve<T>()
    {
        return (T)Resolve(typeof(T));
    }
    
    private object Resolve(Type type)
    {
        // 싱글톤 확인
        if (_singletons.ContainsKey(type))
        {
            return _singletons[type];
        }
        
        // 등록된 타입 확인
        if (_registrations.ContainsKey(type))
        {
            Type implementationType = _registrations[type];
            return CreateInstance(implementationType);
        }
        
        // 구체 타입이면 직접 생성
        if (!type.IsAbstract && !type.IsInterface)
        {
            return CreateInstance(type);
        }
        
        throw new InvalidOperationException($"타입 '{type.Name}'을 해결할 수 없습니다.");
    }
    
    private object CreateInstance(Type type)
    {
        // 생성자 찾기 (매개변수가 가장 많은 것)
        ConstructorInfo[] constructors = type.GetConstructors();
        ConstructorInfo constructor = constructors
            .OrderByDescending(c => c.GetParameters().Length)
            .First();
        
        // 생성자 매개변수 해결
        ParameterInfo[] parameters = constructor.GetParameters();
        object[] parameterInstances = new object[parameters.Length];
        
        for (int i = 0; i < parameters.Length; i++)
        {
            parameterInstances[i] = Resolve(parameters[i].ParameterType);
        }
        
        // 인스턴스 생성
        return constructor.Invoke(parameterInstances);
    }
}

// 사용 예제
public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"[LOG] {message}");
    }
}

public interface IDataService
{
    void SaveData(string data);
}

public class DataService : IDataService
{
    private readonly ILogger _logger;
    
    public DataService(ILogger logger)
    {
        _logger = logger;
    }
    
    public void SaveData(string data)
    {
        _logger.Log($"데이터 저장 중: {data}");
        // 실제 저장 로직...
    }
}

// 컨테이너 설정
SimpleContainer container = new SimpleContainer();
container.RegisterSingleton<ILogger, ConsoleLogger>();
container.Register<IDataService, DataService>();

// 의존성 자동 주입!
IDataService dataService = container.Resolve<IDataService>();
dataService.SaveData("중요한 정보");  // [LOG] 데이터 저장 중: 중요한 정보

시나리오 3: 객체 복사(Deep Clone) 🔄

public class ObjectCloner
{
    public static T DeepClone<T>(T source)
    {
        if (source == null)
            return default(T);
        
        Type type = typeof(T);
        
        // 값 타입이나 string은 그대로 반환
        if (type.IsValueType || type == typeof(string))
            return source;
        
        // 새 인스턴스 생성
        T clone = Activator.CreateInstance<T>();
        
        // 모든 필드 복사 (private 포함)
        FieldInfo[] fields = type.GetFields(
            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
        
        foreach (FieldInfo field in fields)
        {
            object fieldValue = field.GetValue(source);
            
            if (fieldValue != null)
            {
                // 참조 타입이면 재귀적으로 복사
                if (field.FieldType.IsClass && field.FieldType != typeof(string))
                {
                    MethodInfo cloneMethod = typeof(ObjectCloner)
                        .GetMethod("DeepClone")
                        .MakeGenericMethod(field.FieldType);
                    
                    fieldValue = cloneMethod.Invoke(null, new[] { fieldValue });
                }
                
                field.SetValue(clone, fieldValue);
            }
        }
        
        return clone;
    }
}

// 사용 예제
public class Address
{
    public string City { get; set; }
    public string Street { get; set; }
}

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public Address Address { get; set; }
}

Person original = new Person
{
    Name = "김철수",
    Age = 30,
    Address = new Address { City = "서울", Street = "강남대로" }
};

Person cloned = ObjectCloner.DeepClone(original);

// 복사본 수정
cloned.Name = "이영희";
cloned.Address.City = "부산";

Console.WriteLine($"원본: {original.Name}, {original.Address.City}");  
// 출력: 원본: 김철수, 서울

Console.WriteLine($"복사본: {cloned.Name}, {cloned.Address.City}");  
// 출력: 복사본: 이영희, 부산

🚀 재능넷에서 리플렉션 활용하기

재능넷 같은 플랫폼을 개발한다면 리플렉션을 어떻게 활용할 수 있을까? 🤔
몇 가지 실용적인 예제를 살펴보자!

재능 카테고리 자동 등록 시스템 📋

// 재능 카테고리를 나타내는 어트리뷰트
[AttributeUsage(AttributeTargets.Class)]
public class TalentCategoryAttribute : Attribute
{
    public string CategoryName { get; set; }
    public string Description { get; set; }
    public int DisplayOrder { get; set; }
    
    public TalentCategoryAttribute(string categoryName)
    {
        CategoryName = categoryName;
    }
}

// 재능 서비스 인터페이스
public interface ITalentService
{
    string GetServiceName();
    decimal GetPrice();
    void Execute();
}

// 구체적인 재능 서비스들
[TalentCategory("프로그래밍", Description = "소프트웨어 개발 관련", DisplayOrder = 1)]
public class CSharpTutorService : ITalentService
{
    public string GetServiceName() => "C# 프로그래밍 과외";
    public decimal GetPrice() => 50000;
    public void Execute() => Console.WriteLine("C# 강의를 시작합니다!");
}

[TalentCategory("디자인", Description = "그래픽 디자인", DisplayOrder = 2)]
public class LogoDesignService : ITalentService
{
    public string GetServiceName() => "로고 디자인";
    public decimal GetPrice() => 100000;
    public void Execute() => Console.WriteLine("로고 디자인을 시작합니다!");
}

[TalentCategory("번역", Description = "언어 번역 서비스", DisplayOrder = 3)]
public class TranslationService : ITalentService
{
    public string GetServiceName() => "영한 번역";
    public decimal GetPrice() => 30000;
    public void Execute() => Console.WriteLine("번역을 시작합니다!");
}

// 재능 레지스트리 - 자동으로 모든 재능 서비스 검색
public class TalentRegistry
{
    private List<Type> _talentServices = new List<Type>();
    
    public void ScanAssembly()
    {
        Assembly assembly = Assembly.GetExecutingAssembly();
        
        // ITalentService를 구현한 모든 타입 찾기
        var serviceTypes = assembly.GetTypes()
            .Where(t => typeof(ITalentService).IsAssignableFrom(t) && 
                       !t.IsInterface && 
                       !t.IsAbstract);
        
        _talentServices.AddRange(serviceTypes);
        
        Console.WriteLine($"🔍 {_talentServices.Count}개의 재능 서비스를 찾았습니다!\n");
    }
    
    public void DisplayAllTalents()
    {
        // 카테고리별로 그룹화
        var groupedByCategory = _talentServices
            .Select(t => new
            {
                Type = t,
                Attribute = t.GetCustomAttribute<TalentCategoryAttribute>()
            })
            .Where(x => x.Attribute != null)
            .GroupBy(x => x.Attribute.CategoryName)
            .OrderBy(g => g.First().Attribute.DisplayOrder);
        
        foreach (var category in groupedByCategory)
        {
            Console.WriteLine($"📂 카테고리: {category.Key}");
            Console.WriteLine($"   설명: {category.First().Attribute.Description}\n");
            
            foreach (var item in category)
            {
                ITalentService service = (ITalentService)Activator.CreateInstance(item.Type);
                
                Console.WriteLine($"   ✨ {service.GetServiceName()}");
                Console.WriteLine($"      가격: {service.GetPrice():N0}원");
                Console.WriteLine($"      타입: {item.Type.Name}\n");
            }
        }
    }
    
    public ITalentService CreateService(string serviceName)
    {
        Type serviceType = _talentServices
            .FirstOrDefault(t =>
            {
                ITalentService temp = (ITalentService)Activator.CreateInstance(t);
                return temp.GetServiceName().Equals(serviceName, 
                    StringComparison.OrdinalIgnoreCase);
            });
        
        if (serviceType != null)
        {
            return (ITalentService)Activator.CreateInstance(serviceType);
        }
        
        return null;
    }
}

// 사용 예제
TalentRegistry registry = new TalentRegistry();
registry.ScanAssembly();
registry.DisplayAllTalents();

// 특정 서비스 실행
ITalentService service = registry.CreateService("C# 프로그래밍 과외");
if (service != null)
{
    Console.WriteLine($"\n🎯 '{service.GetServiceName()}' 서비스를 시작합니다!");
    service.Execute();
}

이렇게 하면 새로운 재능 서비스를 추가할 때마다
어트리뷰트만 붙이면 자동으로 시스템에 등록돼! 😎
재능넷 같은 플랫폼에서 수백 개의 서비스를 관리할 때 정말 유용하지!

💡 베스트 프랙티스와 팁

🎬 마무리하며

자, 여기까지 C# 리플렉션과 동적 프로그래밍에 대해 알아봤어! 🎉
처음엔 어렵게 느껴질 수 있지만, 한 번 익숙해지면 정말 강력한 도구가 돼.

리플렉션은 마치 프로그램의 X-ray 같아.
코드의 내부 구조를 들여다보고, 런타임에 동적으로 조작할 수 있지.
하지만 강력한 만큼 신중하게 사용해야 해! ⚡

재능넷 같은 플랫폼을 개발하거나, 프레임워크를 만들거나,
유연한 시스템을 구축할 때 리플렉션은 정말 유용한 친구가 될 거야.
성능과 유연성 사이의 균형을 잘 맞추면서 활용해보자! 💪

이 글이 도움이 되었다면, 재능넷에서 다른 유용한 지식들도 찾아보고,
너의 재능도 공유해보는 건 어때? 😊
우리 모두 함께 성장하는 개발자가 되자! 🚀