Mổ gói NuGet trước khi cài: tìm code chạy lúc build và lúc nạp

// SoiGoi.cs: xem tĩnh gói NuGet trước khi cài. Chỉ đọc byte: không nạp assembly, không chạy code nào của gói.
//   dotnet run SoiGoi.cs -- <file.nupkg | thư mục chứa .nupkg>
//   dotnet run SoiGoi.cs -- packages.lock.json [--goc lock-cua-nhanh-chinh.json]   (CI: chỉ soi gói mới)
//   dotnet run SoiGoi.cs -- <thư mục> --tong-hop                                  (chỉ đếm, không in tên gói)
// Mã thoát: 0 khi mọi gói dưới ngưỡng, 2 khi có gói từ ngưỡng trở lên (cần người duyệt), 3 khi không soi được gói nào đó.
using System.Diagnostics;
using System.Globalization;
using System.IO.Compression;
using System.Reflection.Metadata;
using System.Reflection.Metadata.Ecma335;
using System.Reflection.PortableExecutable;
using System.Security.Cryptography;
using System.Text.Json;
using System.Xml.Linq;

const int Nguong = 4;
CultureInfo.CurrentCulture = new CultureInfo("vi-VN");
string vao = args[0];
string? goc = args.SkipWhile(a => a != "--goc").Skip(1).FirstOrDefault();
bool tongHop = args.Contains("--tong-hop");

var dsGoi = new List<(string Ten, string File, string? Hash)>();
if (vao.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
{
    string kho = Environment.GetEnvironmentVariable("NUGET_PACKAGES")
        ?? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".nuget", "packages");
    var cu = goc is null ? [] : DocLock(goc).Select(g => g.Ten).ToHashSet(StringComparer.OrdinalIgnoreCase);
    foreach (var (ten, id, ver, hash) in DocLock(vao).Where(g => !cu.Contains(g.Ten)))
        dsGoi.Add((ten, Path.Combine(kho, id.ToLowerInvariant(), ver.ToLowerInvariant(), $"{id}.{ver}.nupkg".ToLowerInvariant()), hash));
}
else if (Directory.Exists(vao))
    dsGoi.AddRange(Directory.EnumerateFiles(vao, "*.nupkg", SearchOption.AllDirectories).Select(f => (Path.GetFileName(f), f, (string?)null)));
else
    dsGoi.Add((Path.GetFileName(vao), vao, null));

var dem = new SortedDictionary<string, int>();
int chan = 0, tuChay = 0, loi = 0;
var dongHo = Stopwatch.StartNew();
foreach (var (ten, file, hash) in dsGoi)
{
    try
    {
        if (hash is not null && Convert.ToBase64String(SHA512.HashData(File.ReadAllBytes(file))) != hash)
            throw new InvalidDataException("contentHash trong lock file không khớp file .nupkg");
        var (tieuDe, phatHien) = Soi(file);
        var theoNhom = phatHien.GroupBy(p => p.Nhom).Select(g => (Nhom: g.Key, Diem: g.Max(p => p.Diem))).ToList();
        int diem = theoNhom.Sum(n => n.Diem);                // mỗi nhóm lấy mức cao nhất, cộng các nhóm
        foreach (var n in theoNhom) dem[$"{n.Nhom}, {n.Diem} điểm"] = dem.GetValueOrDefault($"{n.Nhom}, {n.Diem} điểm") + 1;
        if (diem >= Nguong) chan++;
        if (theoNhom.Any(n => n.Diem >= 4 && n.Nhom is "build" or "analyzer" or "module initializer")) tuChay++;
        if (tongHop) continue;
        Console.WriteLine($"{tieuDe}\n  điểm {diem}: {(diem == 0 ? "không thấy code tự chạy" : diem < Nguong ? "xem lại" : "CHẶN, cần người duyệt")}");
        foreach (var p in phatHien) Console.WriteLine($"  [{p.Diem}] {p.Nhom}: {p.MoTa}");
    }
    catch (Exception e) { loi++; if (!tongHop) Console.WriteLine($"{ten}\n  LỖI: {e.Message}"); }
}
Console.WriteLine($"\n{dsGoi.Count} gói, {chan} gói từ {Nguong} điểm ({tuChay} gói có code tự chạy lúc build hoặc lúc nạp), {loi} lỗi, {dongHo.ElapsedMilliseconds} ms");
if (tongHop) foreach (var (nhom, n) in dem) Console.WriteLine($"  {nhom}: {n} gói");
return loi > 0 ? 3 : chan > 0 ? 2 : 0;

// ---------- Soi một gói ----------
static (string TieuDe, List<(string Nhom, int Diem, string MoTa)> PhatHien) Soi(string file)
{
    using var zip = ZipFile.OpenRead(file);
    var ph = new List<(string Nhom, int Diem, string MoTa)>();
    var nuspec = XDocument.Load(zip.Entries.Single(e => !e.FullName.Contains('/') && e.Name.EndsWith(".nuspec", StringComparison.OrdinalIgnoreCase)).Open());
    string Meta(string ten) => nuspec.Descendants().FirstOrDefault(x => x.Name.LocalName == ten)?.Value ?? "";
    string tieuDe = $"{Meta("id")} {Meta("version")} ({new FileInfo(file).Length:N0} byte, {zip.Entries.Count} file, tác giả: {Meta("authors")})";

    foreach (var e in zip.Entries.Where(e => e.Length > 0))
    {
        string p = e.FullName.Replace('\\', '/'), thuMuc = p.Split('/')[0].ToLowerInvariant(), duoi = Path.GetExtension(p).ToLowerInvariant();
        bool laBuild = thuMuc is "build" or "buildtransitive" or "buildmultitargeting" or "buildcrosstargeting";
        if (laBuild && duoi is ".targets" or ".props")
            ph.AddRange(SoiMsBuild(p, XDocument.Load(e.Open())));
        else if (duoi == ".ps1" && thuMuc == "tools")
            ph.Add(("script tools/", 1, $"{p}: chỉ chạy với packages.config, không chạy với PackageReference"));
        else if (thuMuc == "contentfiles" && duoi == ".cs")
            ph.Add(("contentFiles", 2, $"{p}: mặc định buildAction Compile, biên dịch thẳng vào project"));
        else if (duoi is ".dll" or ".exe" or ".so" or ".dylib")
        {
            if (thuMuc == "ref") continue;                       // reference assembly: chỉ có chữ ký, không có thân hàm
            using var ms = new MemoryStream();
            e.Open().CopyTo(ms);
            ph.AddRange(SoiAssembly(p, ms.ToArray(), thuMuc == "analyzers", laBuild));
        }
    }
    return (tieuDe, ph);
}

// .props/.targets: Target nào chạy, móc vào đâu, gọi task gì.
static IEnumerable<(string, int, string)> SoiMsBuild(string p, XDocument x)
{
    string[] nguyHiem = ["Exec", "DownloadFile", "UsingTask"];
    var targets = x.Descendants().Where(t => t.Name.LocalName == "Target").ToList();
    if (targets.Count == 0) { yield return ("build", 1, $"{p}: chỉ đặt property/item, không có Target"); yield break; }
    foreach (var t in targets)
    {
        var tasks = t.Elements().Select(c => c.Name.LocalName).Where(n => n is not ("PropertyGroup" or "ItemGroup")).Distinct().ToList();
        string moc = string.Join(" ", new[] { "BeforeTargets", "AfterTargets", "DependsOnTargets" }
            .Select(a => t.Attribute(a) is { } v ? $"{a}={v.Value}" : null).OfType<string>());
        bool nang = tasks.Any(nguyHiem.Contains) || x.Descendants().Any(u => u.Name.LocalName == "UsingTask");
        bool chiGhiLog = tasks.All(n => n is "Message" or "Warning" or "Error");   // task có sẵn, chỉ in ra log
        yield return ("build", nang ? 6 : chiGhiLog ? 1 : 4, $"{p}: Target {t.Attribute("Name")?.Value} ({moc}) gọi {string.Join(", ", tasks.DefaultIfEmpty("không task nào"))}");
    }
}

// Một file nhị phân: native thì chỉ báo có; managed thì đọc metadata.
static IEnumerable<(string, int, string)> SoiAssembly(string p, byte[] bytes, bool laAnalyzer, bool laBuild)
{
    if (!LaAssemblyNet(bytes)) { yield return ("mã máy", 1, $"{p}: native (PE không metadata, ELF, Mach-O), không đọc được"); yield break; }
    using var pe = new PEReader(new MemoryStream(bytes));
    var md = pe.GetMetadataReader();
    if (laBuild) yield return ("build", 4, $"{p}: DLL task MSBuild, chạy trong tiến trình build");

    // Analyzer và source generator: lớp gắn [DiagnosticAnalyzer] hoặc [Generator].
    var lop = md.TypeDefinitions.Select(md.GetTypeDefinition)
        .SelectMany(t => t.GetCustomAttributes().Select(c => TenAttribute(md, md.GetCustomAttribute(c)))
            .Where(a => a is "Microsoft.CodeAnalysis.GeneratorAttribute" or "Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzerAttribute")
            .Select(a => $"{md.GetString(t.Name)} [{a.Split('.')[^1].Replace("Attribute", "")}]")).ToList();
    if (laAnalyzer)
        yield return ("analyzer", 4, $"{p}: chạy trong trình biên dịch; {(lop.Count > 0 ? string.Join(", ", lop) : "DLL phụ trong analyzers/")}");

    // Module initializer: kiểu <Module> (dòng 1 bảng TypeDef) có .cctor.
    var module = md.GetTypeDefinition(MetadataTokens.TypeDefinitionHandle(1));
    if (module.GetMethods().Any(m => md.GetString(md.GetMethodDefinition(m).Name) == ".cctor"))
    {
        var goi = md.MethodDefinitions.Select(md.GetMethodDefinition)
            .Where(m => m.GetCustomAttributes().Any(c => TenAttribute(md, md.GetCustomAttribute(c)) == "System.Runtime.CompilerServices.ModuleInitializerAttribute"))
            .Select(m => $"{md.GetString(md.GetTypeDefinition(m.GetDeclaringType()).Name)}.{md.GetString(m.Name)}");
        yield return ("module initializer", 4, $"{p}: <Module>..cctor chạy trước lời gọi đầu tiên vào assembly; [ModuleInitializer]: {string.Join(", ", goi.DefaultIfEmpty("không rõ"))}");
    }

    // P/Invoke: method có cờ PinvokeImpl, kèm DLL và tên hàm native.
    var pinvoke = md.MethodDefinitions.Select(md.GetMethodDefinition)
        .Where(m => (m.Attributes & System.Reflection.MethodAttributes.PinvokeImpl) != 0)
        .Select(m => m.GetImport()).Select(i => $"{md.GetString(md.GetModuleReference(i.Module).Name)}!{md.GetString(i.Name)}")
        .Distinct().ToList();
    if (pinvoke.Count > 0) yield return ("P/Invoke", 1, $"{p}: {pinvoke.Count} hàm native: {string.Join(", ", pinvoke.Take(5))}{(pinvoke.Count > 5 ? ", ..." : "")}");

    // Lời gọi ra ngoài assembly: bảng MemberRef, mỗi dòng là kiểu::thành viên.
    var goiRa = md.MemberReferences.Select(md.GetMemberReference)
        .Select(m => (Kieu: TenKieu(md, m.Parent), Ten: md.GetString(m.Name), Sig: md.GetBlobBytes(m.Signature))).ToList();
    foreach (var nhom in goiRa.Select(m => PhanLoai(m.Kieu, m.Ten, m.Sig, laAnalyzer)).OfType<(string Nhom, int Diem, string Api)>()
                              .GroupBy(x => (x.Nhom, x.Diem)))
        yield return (nhom.Key.Nhom, nhom.Key.Diem, $"{p}: {string.Join(", ", nhom.Select(x => x.Api).Distinct())}");
}

// Bảng luật: lời gọi nào đáng xem và nặng bao nhiêu.
static (string, int, string)? PhanLoai(string kieu, string ten, byte[] sig, bool laAnalyzer) => (kieu, ten) switch
{
    ("System.Diagnostics.Process", "Start") => ("tiến trình", 4, "Process.Start"),
    ("System.Net.Http.HttpClient" or "System.Net.WebClient" or "System.Net.Sockets.Socket" or "System.Net.Sockets.TcpClient", _)
        => ("mạng", 2, $"{kieu.Split('.')[^1]}.{ten}"),
    ("System.Reflection.Assembly", "Load") when sig.AsSpan().IndexOf([(byte)0x1D, (byte)0x05]) >= 0
        => ("nạp code động", 3, "Assembly.Load(byte[])"),                         // 0x1D 0x05 = byte[] trong chữ ký
    ("System.Reflection.Assembly", "LoadFrom" or "LoadFile" or "UnsafeLoadFrom")
        or ("System.Runtime.Loader.AssemblyLoadContext", "LoadFromStream" or "LoadFromAssemblyPath")
        => ("nạp code động", 3, $"{kieu.Split('.')[^1]}.{ten}"),
    ("System.Reflection.Assembly", "GetManifestResourceStream") => ("nạp code động", 1, "GetManifestResourceStream"),
    ("System.Runtime.InteropServices.NativeLibrary", "Load" or "TryLoad")
        or ("System.Runtime.InteropServices.Marshal", "GetDelegateForFunctionPointer") => ("native động", 2, $"{kieu.Split('.')[^1]}.{ten}"),
    // Trong analyzer: các API mà luật RS1035 cấm analyzer dùng (file, thư mục tạm, biến môi trường, tiến trình).
    ("System.IO.File" or "System.IO.Directory" or "System.Environment" or "System.Diagnostics.Process", _)
        or ("System.IO.Path", "GetTempPath") when laAnalyzer
        => ("I/O trong analyzer", 2, $"{kieu.Split('.')[^1]}.{ten}"),
    _ => null,
};

static bool LaAssemblyNet(byte[] bytes)
{
    try { using var pe = new PEReader(new MemoryStream(bytes)); return pe.HasMetadata; }
    catch (BadImageFormatException) { return false; }             // không phải PE: .so, .dylib
}

static string TenKieu(MetadataReader md, EntityHandle h) => h.Kind switch
{
    HandleKind.TypeReference => md.GetTypeReference((TypeReferenceHandle)h) is var t ? $"{md.GetString(t.Namespace)}.{md.GetString(t.Name)}" : "",
    HandleKind.TypeDefinition => md.GetTypeDefinition((TypeDefinitionHandle)h) is var d ? $"{md.GetString(d.Namespace)}.{md.GetString(d.Name)}" : "",
    _ => "",
};

static string TenAttribute(MetadataReader md, CustomAttribute a) => a.Constructor.Kind switch
{
    HandleKind.MemberReference => TenKieu(md, md.GetMemberReference((MemberReferenceHandle)a.Constructor).Parent),
    HandleKind.MethodDefinition => TenKieu(md, md.GetMethodDefinition((MethodDefinitionHandle)a.Constructor).GetDeclaringType()),
    _ => "",
};

// packages.lock.json: mọi gói (trực tiếp và bắc cầu) của mọi target framework, kèm contentHash.
static IEnumerable<(string Ten, string Id, string Ver, string Hash)> DocLock(string file)
{
    using var doc = JsonDocument.Parse(File.ReadAllText(file));
    return doc.RootElement.GetProperty("dependencies").EnumerateObject()
        .SelectMany(tfm => tfm.Value.EnumerateObject())
        .Where(g => g.Value.TryGetProperty("resolved", out _) && g.Value.TryGetProperty("contentHash", out _))
        .Select(g => (Ten: $"{g.Name}@{g.Value.GetProperty("resolved").GetString()}", Id: g.Name,
                      Ver: g.Value.GetProperty("resolved").GetString()!, Hash: g.Value.GetProperty("contentHash").GetString()!))
        .DistinctBy(g => g.Ten, StringComparer.OrdinalIgnoreCase).ToList();
}

<!-- goi\Directory.Build.props -->
<Project>
  <PropertyGroup>
    <Version>1.0.0</Version>
    <Authors>BHPay thu nghiem</Authors>
    <Description>Goi tu dung cho bai Mo goi NuGet truoc khi cai. Vo hai.</Description>
    <PackageOutputPath>$(MSBuildThisFileDirectory)..\feed</PackageOutputPath>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>
</Project>

<!-- goi\DinhDang\BHPay.TienIch.DinhDang.csproj; NhatKy và MoiTruong giống hệt, chỉ đổi PackageId -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <PackageId>BHPay.TienIch.DinhDang</PackageId>
  </PropertyGroup>
</Project>

<!-- goi\CauHinh\BHPay.TienIch.CauHinh.csproj: đóng file .targets ở mục 3 vào hai thư mục -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <PackageId>BHPay.TienIch.CauHinh</PackageId>
  </PropertyGroup>
  <ItemGroup>
    <None Include="BHPay.TienIch.CauHinh.targets" Pack="true" PackagePath="build/;buildTransitive/" />
  </ItemGroup>
</Project>

<!-- goi\MaLoi\BHPay.TienIch.MaLoi.csproj: DLL đặt vào analyzers/dotnet/cs -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
    <PackageId>BHPay.TienIch.MaLoi</PackageId>
    <LangVersion>latest</LangVersion>
    <ImplicitUsings>disable</ImplicitUsings>
    <IncludeBuildOutput>false</IncludeBuildOutput>
    <SuppressDependenciesWhenPacking>true</SuppressDependenciesWhenPacking>
    <NoWarn>$(NoWarn);NU5128</NoWarn>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" PrivateAssets="all" />
    <None Include="$(OutputPath)\$(AssemblyName).dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
  </ItemGroup>
</Project>

<!-- goi\nuget.config: chỉ dùng để đóng gói MaLoi, cần Microsoft.CodeAnalysis.CSharp -->
<configuration>
  <packageSources>
    <clear />
    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
  </packageSources>
</configuration>

// ===== goi\DinhDang\DinhDang.cs =====
using System.Globalization;
namespace BHPay.TienIch;

public static class DinhDang
{
    static readonly NumberFormatInfo Vn = new() { NumberGroupSeparator = ".", NumberDecimalSeparator = "," };

    // 1500000m -> "1.500.000 đ"
    public static string Tien(decimal soTien) => soTien.ToString("#,0", Vn) + " đ";
}

// ===== goi\CauHinh\CauHinh.cs =====
namespace BHPay.TienIch;

public static class CauHinh
{
    public const string MoiTruong = "thu-nghiem";
}

// ===== goi\MaLoi\MaLoiGenerator.cs =====
using System;
using System.IO;
using Microsoft.CodeAnalysis;

namespace BHPay.TienIch;

// Source generator sinh hằng mã lỗi của BHPay.
[Generator]
public sealed class MaLoiGenerator : IIncrementalGenerator
{
    public void Initialize(IncrementalGeneratorInitializationContext context)
    {
        // Mẫu vô hại: ghi một file đánh dấu để thấy code của gói chạy bên trong trình biên dịch.
        string thuMuc = Path.Combine(Path.GetTempPath(), "soi-goi-danh-dau");
        Directory.CreateDirectory(thuMuc);
        File.AppendAllText(Path.Combine(thuMuc, "maloi-generator.txt"),
            $"generator chay trong {Path.GetFileName(Environment.GetCommandLineArgs()[0])} pid {System.Diagnostics.Process.GetCurrentProcess().Id} {DateTime.Now:HH:mm:ss.fff}\n");

        context.RegisterPostInitializationOutput(ctx => ctx.AddSource("MaLoi.g.cs",
            "namespace BHPay.TienIch { public static class MaLoi { public const int SoDuKhongDu = 50010; public const int ViKhongTonTai = 50011; } }"));
    }
}

// ===== goi\NhatKy\NhatKy.cs =====
using System.Runtime.CompilerServices;
namespace BHPay.TienIch;

public static class NhatKy
{
    public static string Dong(string noiDung) => $"[nhat-ky] {noiDung}";
}

static class KhoiDong
{
    // Mẫu vô hại: ghi một file đánh dấu khi module được khởi tạo, trước mọi lời gọi của app.
    [ModuleInitializer]
    internal static void Chay()
    {
        string thuMuc = Path.Combine(Path.GetTempPath(), "soi-goi-danh-dau");
        Directory.CreateDirectory(thuMuc);
        File.AppendAllText(Path.Combine(thuMuc, "nhatky-module-init.txt"),
            $"module initializer chay trong {Path.GetFileName(Environment.ProcessPath)} {DateTime.Now:HH:mm:ss.fff}\n");
    }
}

// ===== goi\MoiTruong\MoiTruong.cs =====
using System.Diagnostics;
namespace BHPay.TienIch;

public static class MoiTruong
{
    // Mẫu vô hại: gọi cmd chỉ để in một dòng.
    public static string KiemTra()
    {
        var psi = new ProcessStartInfo("cmd.exe", "/c echo BHPay.TienIch.MoiTruong da goi cmd")
        {
            RedirectStandardOutput = true,
            UseShellExecute = false,
        };
        using var p = Process.Start(psi)!;
        string dong = p.StandardOutput.ReadToEnd().Trim();
        p.WaitForExit();
        return dong;
    }
}

param([string[]]$Goi = @("DinhDang","CauHinh","MaLoi","NhatKy","MoiTruong"))
# Thử từng gói trong một project console .NET 10 mới, ghi lại file đánh dấu xuất hiện sau mỗi pha.
$re = $PSScriptRoot      # thư mục chứa script, feed\ và goi\
$env:NUGET_PACKAGES = "$re\nuget-cache"
$env:DOTNET_CLI_TELEMETRY_OPTOUT = "1"
$danhDau = Join-Path ([IO.Path]::GetTempPath()) "soi-goi-danh-dau"
$code = @{
  DinhDang  = 'Console.WriteLine(BHPay.TienIch.DinhDang.Tien(1500000m));'
  CauHinh   = 'Console.WriteLine(BHPay.TienIch.CauHinh.MoiTruong);'
  MaLoi     = 'Console.WriteLine(BHPay.TienIch.MaLoi.SoDuKhongDu);'
  NhatKy    = 'Console.WriteLine("truoc loi goi dau tien, co danh dau: " + System.IO.Directory.Exists(System.IO.Path.Combine(System.IO.Path.GetTempPath(), "soi-goi-danh-dau"))); Goi(); static void Goi() => Console.WriteLine(BHPay.TienIch.NhatKy.Dong("da goi"));'
  MoiTruong = 'Console.WriteLine(BHPay.TienIch.MoiTruong.KiemTra());'
}
function DanhDau { if (Test-Path -LiteralPath $danhDau) { (Get-ChildItem -LiteralPath $danhDau | ForEach-Object { "$($_.Name): " + ((Get-Content -LiteralPath $_.FullName) -join ' | ') }) -join '; ' } else { "-" } }
function XoaDanhDau { if (Test-Path -LiteralPath $danhDau) { Get-ChildItem -LiteralPath $danhDau -File | ForEach-Object { [IO.File]::Delete($_.FullName) }; [IO.Directory]::Delete($danhDau) } }
foreach ($g in $Goi) {
  $dir = "$re\thu\$g"
  if (Test-Path -LiteralPath $dir) { [IO.Directory]::Delete($dir, $true) }
  New-Item -ItemType Directory -Force $dir | Out-Null
  @"
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <packageSources>
    <clear />
    <add key="feed-cuc-bo" value="$re\feed" />
  </packageSources>
</configuration>
"@ | Set-Content -Encoding utf8 "$dir\nuget.config"
  @"
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="BHPay.TienIch.$g" Version="1.0.0" />
  </ItemGroup>
</Project>
"@ | Set-Content -Encoding utf8 "$dir\Thu$g.csproj"
  $code[$g] | Set-Content -Encoding utf8 "$dir\Program.cs"
  XoaDanhDau
  "== $g"
  dotnet restore "$dir\Thu$g.csproj" -nologo -v q | Out-Null;           "restore 1: $(DanhDau)"
  dotnet restore "$dir\Thu$g.csproj" -nologo -v q | Out-Null;           "restore 2: $(DanhDau)"
  dotnet build "$dir\Thu$g.csproj" --no-restore -nologo -v q | Out-Null; "build    : $(DanhDau)"
  $out = dotnet run --project "$dir\Thu$g.csproj" --no-build 2>&1;      "run out  : $($out -join ' | ')"
  "run      : $(DanhDau)"
}

// Kiểm module initializer chạy lúc nào: chỉ nạp assembly, đọc kiểu bằng reflection, hay khi gọi method.
using System.Reflection;

string dll = args[0];
string danhDau = Path.Combine(Path.GetTempPath(), "soi-goi-danh-dau", "nhatky-module-init.txt");
if (File.Exists(danhDau)) File.Delete(danhDau);

var asm = Assembly.LoadFrom(dll);
Console.WriteLine($"sau LoadFrom: {File.Exists(danhDau)}");
var kieu = asm.GetTypes();
Console.WriteLine($"sau GetTypes ({kieu.Length} kieu): {File.Exists(danhDau)}");
var dong = asm.GetType("BHPay.TienIch.NhatKy")!.GetMethod("Dong")!;
Console.WriteLine($"sau GetMethod: {File.Exists(danhDau)}");
dong.Invoke(null, ["x"]);
Console.WriteLine($"sau Invoke: {File.Exists(danhDau)}");

== DinhDang
restore 1: -
restore 2: -
build    : -
run out  : 1.500.000 đ
run      : -
== CauHinh
restore 1: -
restore 2: -
build    : cauhinh-targets.txt: targets chay luc build: ThuCauHinh 17:22:04.172
run out  : thu-nghiem
run      : cauhinh-targets.txt: targets chay luc build: ThuCauHinh 17:22:04.172
== MaLoi
restore 1: -
restore 2: -
build    : maloi-generator.txt: generator chay trong VBCSCompiler.dll pid 43092 17:22:11.603
run out  : 50010
run      : maloi-generator.txt: generator chay trong VBCSCompiler.dll pid 43092 17:22:11.603
== NhatKy
restore 1: -
restore 2: -
build    : -
run out  : truoc loi goi dau tien, co danh dau: False | [nhat-ky] da goi
run      : nhatky-module-init.txt: module initializer chay trong ThuNhatKy.exe 17:22:21.730
== MoiTruong
restore 1: -
restore 2: -
build    : -
run out  : BHPay.TienIch.MoiTruong da goi cmd
run      : -