Type userType = typeof(User);

// Властивості Type
Console.WriteLine(userType.Name);          // "User"
Console.WriteLine(userType.FullName);      // "MyApp.Models.User"
Console.WriteLine(userType.Namespace);     // "MyApp.Models"
Console.WriteLine(userType.IsClass);       // True
Console.WriteLine(userType.IsValueType);   // False
Console.WriteLine(userType.IsSealed);      // False
Console.WriteLine(userType.BaseType);      // System.Object

using System.Reflection;

public class User
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    private string _password = "secret";
}

Type userType = typeof(User);

// Отримати всі публічні властивості
PropertyInfo[] publicProps = userType.GetProperties();

foreach (PropertyInfo prop in publicProps)
{
    Console.WriteLine($"{prop.Name} ({prop.PropertyType.Name})");
    // Output:
    // Id (Int32)
    // Name (String)
}

// Отримати приватні поля (flags: BindingFlags)
FieldInfo[] privateFields = userType.GetFields(
    BindingFlags.NonPublic | BindingFlags.Instance
);

foreach (FieldInfo field in privateFields)
{
    Console.WriteLine($"{field.Name} ({field.FieldType.Name})");
    // Output: _password (String)
}

public class Calculator
{
    public int Add(int a, int b) => a + b;
    private int Multiply(int a, int b) => a * b;
}

Calculator calc = new();
Type calcType = typeof(Calculator);

// Публічний метод
MethodInfo? addMethod = calcType.GetMethod("Add");
if (addMethod != null)
{
    object? result = addMethod.Invoke(calc, new object[] { 5, 3 });
    Console.WriteLine(result); // 8
}

// Приватний метод (потрібен BindingFlags.NonPublic)
MethodInfo? multiplyMethod = calcType.GetMethod("Multiply",
    BindingFlags.NonPublic | BindingFlags.Instance);

if (multiplyMethod != null)
{
    object? result = multiplyMethod.Invoke(calc, new object[] { 4, 7 });
    Console.WriteLine(result); // 28
}

User user = new() { Id = 1, Name = "Alice" };
Type userType = typeof(User);

PropertyInfo? nameProp = userType.GetProperty("Name");

if (nameProp != null)
{
    // Читання
    string? currentName = nameProp.GetValue(user) as string;
    Console.WriteLine(currentName); // "Alice"

    // Запис
    nameProp.SetValue(user, "Bob");
    Console.WriteLine(user.Name); // "Bob"
}

string? name = nameProp?.GetValue(user) as string;

Type listType = typeof(List<int>);
object? instance = Activator.CreateInstance(listType);

if (instance is List<int> list)
{
    list.Add(42);
    Console.WriteLine(list[0]); // 42
}

// З параметрами конструктора
Type userType = typeof(User);
User? user = Activator.CreateInstance(userType, new object[] { 123, "John" }) as User;

Type userType = typeof(User);

// Знайти конструктор з параметрами
ConstructorInfo? ctor = userType.GetConstructor(new[] { typeof(int), typeof(string) });

if (ctor != null)
{
    User user = (User)ctor.Invoke(new object[] { 99, "Alice" });
    Console.WriteLine(user.Name); // "Alice"
}

// Open generic type (без аргументів типу)
Type openListType = typeof(List<>);
Console.WriteLine(openListType.IsGenericTypeDefinition); // True

// Closed generic type (з конкретним T)
Type closedListType = typeof(List<int>);
Console.WriteLine(closedListType.IsGenericType); // True

// Отримати аргументи типу
Type[] genericArgs = closedListType.GetGenericArguments();
Console.WriteLine(genericArgs[0]); // System.Int32

// Створити закритий тип з відкритого
Type constructedType = openListType.MakeGenericType(typeof(string));
object? stringList = Activator.CreateInstance(constructedType);
// stringList тепер є List<string>

using BenchmarkDotNet.Attributes;

public class ReflectionBenchmark
{
    private readonly Calculator _calc = new();
    private readonly MethodInfo _addMethod = typeof(Calculator).GetMethod("Add")!;

    [Benchmark(Baseline = true)]
    public int DirectCall() => _calc.Add(5, 3);

    [Benchmark]
    public int ReflectionCall() => (int)_addMethod.Invoke(_calc, new object[] { 5, 3 })!;
}

using System.Linq.Expressions;

public static Func<Calculator, int, int, int> CreateDelegate()
{
    MethodInfo method = typeof(Calculator).GetMethod("Add")!;

    ParameterExpression instance = Expression.Parameter(typeof(Calculator));
    ParameterExpression arg1 = Expression.Parameter(typeof(int));
    ParameterExpression arg2 = Expression.Parameter(typeof(int));

    MethodCallExpression call = Expression.Call(instance, method, arg1, arg2);

    return Expression.Lambda<Func<Calculator, int, int, int>>(call, instance, arg1, arg2).Compile();
}

// Використання (швидкість майже як прямий виклик)
var addDelegate = CreateDelegate();
int result = addDelegate(new Calculator(), 5, 3); // 8

using System.Reflection;

// Завантажити поточну збірку
Assembly currentAssembly = Assembly.GetExecutingAssembly();
Console.WriteLine(currentAssembly.FullName);

// Завантажити збірку з файлу
Assembly loadedAssembly = Assembly.LoadFrom("MyPlugin.dll");

// Отримати всі типи зі збірки
Type[] types = loadedAssembly.GetTypes();

foreach (Type type in types)
{
    if (type.IsClass && !type.IsAbstract && typeof(IPlugin).IsAssignableFrom(type))
    {
        // Знайдено клас, що реалізує IPlugin
        IPlugin? plugin = Activator.CreateInstance(type) as IPlugin;
        plugin?.Execute();
    }
}

using System.Reflection;
using System.Reflection.Emit;

AssemblyName assemblyName = new("DynamicAssembly");
AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(
    assemblyName, AssemblyBuilderAccess.Run
);

ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule");

TypeBuilder typeBuilder = moduleBuilder.DefineType(
    "DynamicType",
    TypeAttributes.Public
);

// Додати поле
FieldBuilder fieldBuilder = typeBuilder.DefineField(
    "_value",
    typeof(int),
    FieldAttributes.Private
);

// Створити тип
Type? dynamicType = typeBuilder.CreateType();
object? instance = Activator.CreateInstance(dynamicType!);

Type: System.String
Base: System.Object

Properties:
  - Length: Int32

Methods:
  - ToUpper(): String
  - Substring(Int32, Int32): String

Factory<User> factory = new();
User user = factory.Create(42, "Alice");

UserDto dto = AutoMapper.Map<User, UserDto>(user);