AppDomain domain = AppDomain.CurrentDomain;

// 1. Базова директорія — де знаходяться збірки застосунку
Console.WriteLine($"BaseDirectory: {domain.BaseDirectory}");
// → C:\Projects\MyApp\

// 2. Ім'я домену — корисно для logging у бібліотеках
Console.WriteLine($"FriendlyName: {domain.FriendlyName}");
// → MyApp (або ім'я .exe файлу)

// 3. Глобальна обробка непійманих виключень
domain.UnhandledException += (sender, e) =>
{
    var ex = (Exception)e.ExceptionObject;
    bool isTerminating = e.IsTerminating;

    // Останній шанс зафіксувати fatal error перед завершенням процесу
    File.AppendAllText("crash.log",
        $"[{DateTime.UtcNow:O}] FATAL: {ex.GetType().Name}: {ex.Message}\n{ex.StackTrace}\n");
};

// 4. Спостереження за завантаженими збірками
domain.AssemblyLoad += (sender, e) =>
{
    Console.WriteLine($"Завантажено збірку: {e.LoadedAssembly.GetName().Name}");
};

// 5. Перелік завантажених збірок
foreach (var assembly in domain.GetAssemblies())
{
    var name = assembly.GetName();
    Console.WriteLine($"  {name.Name} v{name.Version}  ({(assembly.IsDynamic ? "dynamic" : assembly.Location)})");
}

// 6. Кастомний Assembly Resolver (якщо стандартний не знаходить збірку)
domain.AssemblyResolve += (sender, e) =>
{
    Console.WriteLine($"Не знайдено збірки: {e.Name}");
    // Можна повернути Assembly або null (продовжить стандартний пошук)
    var customPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "plugins",
        new AssemblyName(e.Name!).Name + ".dll");
    return File.Exists(customPath) ? Assembly.LoadFrom(customPath) : null;
};

using System.Reflection;
using System.Runtime.Loader;

// 1. Default — головний контекст застосунку
var defaultAlc = AssemblyLoadContext.Default;
Console.WriteLine($"Default ALC: {defaultAlc.Name}");
// → Default

// 2. GetLoadContext — в якому ALC знаходиться конкретна збірка?
var alc = AssemblyLoadContext.GetLoadContext(typeof(string).Assembly);
Console.WriteLine(alc?.Name);  // → "Default" (System.Runtime у Default)

// 3. Прямий non-collectible контекст (для довгоживучих плагінів)
var permanentAlc = new AssemblyLoadContext("PermanentPlugin", isCollectible: false);
var assembly1 = permanentAlc.LoadFromAssemblyPath("/path/to/StablePlugin.dll");
// Цей ALC не можна вивантажити — збірки живуть вічно

// 4. Collectible контекст (для hot-reload плагінів)
var hotReloadAlc = new AssemblyLoadContext("HotReloadPlugin", isCollectible: true);
var assembly2 = hotReloadAlc.LoadFromAssemblyPath("/path/to/Plugin.dll");
// Пізніше можна вивантажити:
hotReloadAlc.Unload();  // позначаємо для вивантаження
// Фактичне вивантаження — після GC.Collect() і відсутності посилань

using System.Reflection;
using System.Runtime.Loader;

var alc = new AssemblyLoadContext("demo", isCollectible: true);

// 1. За шляхом до файлу (найпоширеніший для плагінів)
Assembly byPath = alc.LoadFromAssemblyPath(
    @"C:\Plugins\MyPlugin.dll");

// 2. За AssemblyName (з GAC або runtime paths)
Assembly byName = alc.LoadFromAssemblyName(
    new AssemblyName("System.Text.Json, Version=8.0.0.0"));

// 3. Зі Stream (наприклад, з вбудованого ресурсу або blob storage)
using var stream = File.OpenRead(@"C:\Plugins\AnotherPlugin.dll");
// Опціонально: другий stream для PDB (символи для debugging)
using var pdbStream = File.OpenRead(@"C:\Plugins\AnotherPlugin.pdb");
Assembly fromStream = alc.LoadFromStream(stream, pdbStream);

using System.Runtime.Loader;
using System.Reflection;

class PluginLoadContext : AssemblyLoadContext
{
    private readonly AssemblyDependencyResolver _resolver;

    public PluginLoadContext(string pluginMainAssemblyPath)
        : base(name: $"Plugin:{Path.GetFileNameWithoutExtension(pluginMainAssemblyPath)}",
               isCollectible: true)
    {
        // Resolver вичитує pluginMainAssemblyPath.deps.json
        // і знає де лежать всі NuGet-залежності плагіна
        _resolver = new AssemblyDependencyResolver(pluginMainAssemblyPath);
    }

    protected override Assembly? Load(AssemblyName assemblyName)
    {
        // Запитуємо resolver: чи є ця збірка серед залежностей плагіна?
        string? assemblyPath = _resolver.ResolveAssemblyToPath(assemblyName);

        if (assemblyPath is not null)
        {
            // Завантажуємо з диску в ІЗОЛЬОВАНий контекст плагіна
            return LoadFromAssemblyPath(assemblyPath);
        }

        // Не знайшли у залежностях плагіна → повертаємо null
        // ALC pipeline піде до Default ALC (там: System.*, Microsoft.*, PluginContracts)
        return null;
    }

    protected override IntPtr LoadUnmanagedDll(string unmanagedDllName)
    {
        // Аналогічно для native DLL (libsqlite.so, sqlite3.dll тощо)
        string? libraryPath = _resolver.ResolveUnmanagedDllToPath(unmanagedDllName);
        return libraryPath is not null
            ? LoadUnmanagedDllFromPath(libraryPath)
            : IntPtr.Zero;
    }
}

using System.Runtime.Loader;

WeakReference? alcRef = null;

// Завантаження у окремому методі — важливо!
// Щоб local змінна 'alc' точно вийшла зі scope перед GC.Collect()
[MethodImpl(MethodImplOptions.NoInlining)]  // запобігаємо inlining — інакше JIT може залишити ref
void LoadAndUse()
{
    var alc = new AssemblyLoadContext("temp", isCollectible: true);
    alcRef = new WeakReference(alc, trackResurrection: true);

    var assembly = alc.LoadFromAssemblyPath("/path/to/plugin.dll");
    var type = assembly.GetType("PluginClass");
    var instance = Activator.CreateInstance(type!);

    // Викликаємо через reflection
    type!.GetMethod("DoWork")?.Invoke(instance, null);

    // По виходу з методу: alc, assembly, type, instance виходять зі scope
    alc.Unload();
}

LoadAndUse();

// Форсуємо GC кілька разів (може знадобитися 2-3 покоління)
for (int i = 0; i < 10 && alcRef.IsAlive; i++)
{
    GC.Collect();
    GC.WaitForPendingFinalizers();
    GC.Collect();  // другий збір — для фіналізаторів
}

Console.WriteLine($"ALC вивантажено: {!alcRef.IsAlive}");

using System.Runtime.Loader;

// trackResurrection: true — відстежуємо навіть після фіналізації
var alcWeakRef = new WeakReference<AssemblyLoadContext>(alc, trackResurrection: true);

alc.Unload();
alc = null!;  // очищаємо strong reference

// Перевірка після GC
for (int attempt = 0; attempt < 10; attempt++)
{
    GC.Collect();
    GC.WaitForPendingFinalizers();
    GC.Collect();

    if (!alcWeakRef.TryGetTarget(out _))
    {
        Console.WriteLine($"✅ ALC вивантажено після {attempt + 1} спроб GC");
        break;
    }

    await Task.Delay(100);  // невелика пауза між спробами
}

if (alcWeakRef.TryGetTarget(out _))
{
    Console.WriteLine("⚠️ ALC не вивантажено — є активні посилання!");
    // Можливі причини: static поля, events, active threads, GCHandles
}

using System.Reflection;

var assembly = Assembly.GetExecutingAssembly();

// --- Ідентичність ---
AssemblyName name = assembly.GetName();
Console.WriteLine($"Name:    {name.Name}");
Console.WriteLine($"Version: {name.Version}");
Console.WriteLine($"Culture: {(name.CultureName == "" ? "neutral" : name.CultureName)}");

// PublicKeyToken — для Strong Named збірок (підписаних)
byte[]? publicKeyToken = name.GetPublicKeyToken();
if (publicKeyToken?.Length > 0)
{
    string token = string.Concat(publicKeyToken.Select(b => b.ToString("x2")));
    Console.WriteLine($"PublicKeyToken: {token}");
    Console.WriteLine("Збірка: STRONG NAMED ✅");
}
else
{
    Console.WriteLine("Збірка: НЕ strong-named (development mode)");
}

// --- Атрибути збірки ---
string? title       = assembly.GetCustomAttribute<AssemblyTitleAttribute>()?.Title;
string? description = assembly.GetCustomAttribute<AssemblyDescriptionAttribute>()?.Description;
string? company     = assembly.GetCustomAttribute<AssemblyCompanyAttribute>()?.Company;
string? copyright   = assembly.GetCustomAttribute<AssemblyCopyrightAttribute>()?.Copyright;
string? product     = assembly.GetCustomAttribute<AssemblyProductAttribute>()?.Product;

// InformationalVersion: семантична версія типу "1.2.3-preview.4+abc1234"
string? infoVersion = assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion;

Console.WriteLine($"\nTitle:       {title}");
Console.WriteLine($"Description: {description}");
Console.WriteLine($"Company:     {company}");
Console.WriteLine($"Version:     {name.Version}");
Console.WriteLine($"InfoVersion: {infoVersion}");
Console.WriteLine($"Copyright:   {copyright}");
Console.WriteLine($"Location:    {assembly.Location}");
Console.WriteLine($"Dynamic:     {assembly.IsDynamic}");  // true для Emit або Source Generator

// --- Залежності ---
Console.WriteLine("\nЗалежності:");
foreach (var dep in assembly.GetReferencedAssemblies().OrderBy(a => a.Name))
    Console.WriteLine($"  {dep.Name} v{dep.Version}");

using System.Reflection;

Assembly assembly = Assembly.LoadFrom("MyLibrary.dll");

// GetExportedTypes() — лише public типи (без internal)
// GetTypes() — всі, включаючи internal та вкладені
foreach (Type type in assembly.GetExportedTypes().OrderBy(t => t.FullName))
{
    string typeKind = type switch
    {
        { IsInterface: true }  => "interface",
        { IsAbstract: true }   => "abstract class",
        { IsEnum: true }       => "enum",
        { IsValueType: true }  => "struct",
        _                      => "class"
    };

    // Базовий клас (якщо не object)
    string baseInfo = type.BaseType is not null && type.BaseType != typeof(object)
        ? $" : {type.BaseType.Name}"
        : "";

    // Реалізовані інтерфейси
    string interfaces = type.GetInterfaces().Length > 0
        ? $" [{string.Join(", ", type.GetInterfaces().Select(i => i.Name))}]"
        : "";

    Console.WriteLine($"{typeKind} {type.FullName}{baseInfo}{interfaces}");

    // Публічні методи (без успадкованих від object)
    foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
    {
        var parameters = string.Join(", ",
            method.GetParameters().Select(p => $"{p.ParameterType.Name} {p.Name}"));
        Console.WriteLine($"    {method.ReturnType.Name} {method.Name}({parameters})");
    }
}