C#中顺序执行Python脚本时如何正确重启PythonNet避免内存访问错误？

算力阿峰

2026-6-16

问题描述

在C#应用中使用PythonNet顺序运行多个不同模块的Python脚本时，频繁出现无规律的MemoryAccessViolation错误：

错误触发时机随机，可能出现在脚本执行中、程序关闭时，甚至无明显诱因
复用同一PythonNet实例或尝试关闭重启实例都会触发内存访问问题
错误无法被try-catch捕获，常直接导致程序以访问违例码崩溃

相关代码片段

/// <summary>
/// Manages the Python environment using pythonnet.
/// </summary>
public class PythonNetEnv : IDisposable
{
    /// <summary>
    /// Indicates if the environment is initialized.
    /// </summary>
    public bool IsInitialized { get; private set; }

    private readonly PythonEnv _env;
    private PythonEngine? _engine;
    private string? _originalPath;
    private string? _originalPythonhome;
    private CancellationTokenSource _cts = new();

    /// <summary>
    /// Initializes a new instance of the <see cref="PythonNetEnv"/> class.
    /// </summary>
    /// <param name="pythonEnv">The path to the Python environment directory.</param>
    public PythonNetEnv(PythonEnv pythonEnv)
    {
        _env = pythonEnv;
        Initialize();
    }

    /// <summary>
    /// Initializes the Python environment.
    /// </summary>
    private void Initialize()
    {
        if (IsInitialized) return;

        // Construct the necessary paths
        string scriptsPath = Path.Combine(_env.EnvPath, "Scripts");
        string libraryPath = Path.Combine(_env.EnvPath, "Library");
        string binPath = Path.Combine(_env.EnvPath, "bin");
        string executablePath = Path.Combine(_env.EnvPath, "Library", "bin");
        string mingwBinPath = Path.Combine(_env.EnvPath, "Library", "mingw-w64", "bin");

        // Get the current PATH environment variable
        _originalPath = Environment.GetEnvironmentVariable("PATH");
        _originalPythonhome = Environment.GetEnvironmentVariable("PYTHONHOME");

        // Set the new PATH environment variable
        string newPath = $"{_env.EnvPath};{scriptsPath};{libraryPath};{binPath};{executablePath};{mingwBinPath};{_originalPath}";
        Environment.SetEnvironmentVariable("PATH", newPath, EnvironmentVariableTarget.Process);

        // Set the PYTHONHOME environment variable
        Environment.SetEnvironmentVariable("PYTHONHOME", _env.EnvPath, EnvironmentVariableTarget.Process);

        // Extract the major and minor version numbers from the provided version string
        string[] versionParts = _env.Version.Split('.');
        if (versionParts.Length < 2)
            throw new ArgumentException("Invalid Python version format. Expected format: main.current.path (e.g., 3.8.20)");

        string majorVersion = versionParts[0];
        string minorVersion = versionParts[1];

        // Construct the Python runtime DLL path based on the version
        string pythonDllPath = Path.Combine(_env.EnvPath, $"python{majorVersion}{minorVersion}.dll");

        // Explicitly set the Python runtime DLL path
        Runtime.PythonDLL = pythonDllPath;

        // Set PythonEngine.PythonHome
        PythonEngine.PythonHome = _env.EnvPath;
        if (!PythonEngine.IsInitialized)
            _engine = new PythonEngine();

        // Allow Python threads to run independently of the main thread
        PythonEngine.BeginAllowThreads();

        IsInitialized = true;
    }

    /// <summary>
    /// Runs a Python script from a specific path with specified arguments.
    /// </summary>
    /// <param name="scriptPath">The path to the Python script.</param>
    /// <param name="workingDirectory">The working directory for the script.</param>
    /// <param name="arguments">The arguments to pass to the script.</param>
    public async Task RunPythonScript(string scriptPath, string workingDirectory, string arguments)
    {
        if (!IsInitialized) throw new InvalidOperationException("Python environment is not initialized.");
        await Task.Run(() =>
        {
            string currentDictionary = Environment.CurrentDirectory;
            using (Py.GIL())
            {
                try
                {
                    Environment.CurrentDirectory = workingDirectory;
                    dynamic sys = Py.Import("sys");
                    dynamic io = Py.Import("io");

                    string moduleName = Path.GetFileNameWithoutExtension(scriptPath);
                    Debug.WriteLine($"Importing module: {moduleName}");

                    dynamic stdout_capture = io.StringIO();
                    dynamic stderr_capture = io.StringIO();
                    sys.stdout = stdout_capture;
                    sys.stderr = stderr_capture;
                    _cts = new CancellationTokenSource();
                    _ = Task.Run(() => CaptureOutput(stdout_capture, _cts.Token));
                    _ = Task.Run(() => CaptureOutput(stderr_capture, _cts.Token));

                    try
                    {
                        ExecutePythonScript(scriptPath);
                    }
                    finally
                    {
                        _cts.Cancel();
                        RestoreStandardOutputs(sys, stdout_capture, stderr_capture);
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Error: {ex.Message}");
                    Console.WriteLine($"Stack Trace: {ex.StackTrace}");
                }
            }
            Environment.CurrentDirectory = currentDictionary;
        });
    }

    private async Task CaptureOutput(dynamic captureStream, CancellationToken token)
    {
        string currentOutput = "";
        while (!token.IsCancellationRequested)
        {
            try
            {
                using (Py.GIL())
                {
                    var currentOutputValue = captureStream.getvalue();
                    if (currentOutputValue != null)
                        currentOutput = currentOutputValue.ToString(); // 错误有时在此处触发，try-catch无法阻止程序退出
                }
            }
            catch (System.AccessViolationException ex) { Debug.WriteLine(ex); }
           // 其他无关代码...
        }
    }

    private static void ExecutePythonScript(string scriptPath)
    {
        using (Py.GIL())
        {
            using dynamic scope = Py.CreateScope();
            scope.Set("__name__", "__main__");
            scope.Exec(File.ReadAllText(scriptPath)); // 错误有时在此处触发，try-catch无法阻止程序退出
        }
    }

    private static void RestoreStandardOutputs(dynamic sys, dynamic stdout_capture, dynamic stderr_capture)
    {
        using (Py.GIL())
        {
            sys.stdout = sys.__stdout__;
            sys.stderr = sys.__stderr__;
            _ = stdout_capture.getvalue().ToString();
            _ = stderr_capture.getvalue().ToString();
        }
    }

    /// <summary>
    /// Disposes of the Python environment, shutting down the Python engine.
    /// </summary>
    public void Dispose()
    {
        if (!IsInitialized)
            return;

        try
        {
            _cts.Dispose();
            Debug.WriteLine("Shutdown");

            PythonEngine.Shutdown(); // 此处最常触发错误，catch无法捕获
            _engine?.Dispose();
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex);
        }
        finally
        {
            Environment.SetEnvironmentVariable("PATH", _originalPath, EnvironmentVariableTarget.Process);
            Environment.SetEnvironmentVariable("PYTHONHOME", _originalPythonhome, EnvironmentVariableTarget.Process);

        }
    }
}

额外细节

错误通常在第三次调用时出现，首次、第二次调用一般正常
执行流程为：创建PythonNetEnv对象 → 运行脚本 → 释放对象 → 创建新对象重复流程
错误出现位置随机，代码中已标记可能触发的点
有时程序无任何报错信息，直接以访问违例码终止
程序运行结束关闭时，是错误高发期

具体问题

如何在不同Python脚本执行之间正确重置或重启PythonNet以避免内存访问错误？
是否有办法确保每个Python脚本在PythonNet中运行于完全隔离的环境？
这些随机访问违例的原因可能是什么，如何预防？

解决方案与分析

1. 正确重置/重启PythonNet的方法

PythonNet的PythonEngine.Shutdown()并非完全可靠，多次初始化/销毁引擎极易引发内存泄漏或访问违例——核心原因是Python解释器本身设计为单进程单实例，无法安全地在同一进程内多次启动和关闭。

可行的替代方案：

复用单个PythonEngine实例：全局维护一个实例，通过独立的PyScope隔离不同脚本的执行环境。每次运行脚本时创建新的PyScope，执行完毕后显式释放该作用域内的所有Python对象，避免残留。
进程隔离：如果必须完全隔离环境，将每个Python脚本的执行逻辑封装到独立的子进程中，C#主进程通过管道、共享内存等方式传递数据和结果。这种方式彻底避免了同一进程内的内存冲突，是最稳定的隔离方案。

2. 实现Python脚本的完全隔离

在同一PythonEngine实例内无法做到100%环境隔离，但可以通过以下方式最大化隔离：

为每个脚本创建独立的PyScope，不共享全局变量或模块引用，执行完毕后调用scope.Dispose()清理。
避免修改Python全局状态（如sys.path、sys.stdout），若必须修改，执行后立即恢复初始状态。
使用Python的importlib模块动态加载脚本，减少全局模块污染（注意Python本身不支持完全卸载模块，只能通过作用域隔离降低影响）。

若需要严格隔离，子进程方案是唯一可靠选择：每个脚本在独立的Python进程中运行，C#主进程启动子进程并监控其输出和退出状态，完全避免内存共享问题。

3. 随机访问违例的原因与预防

常见原因

GIL管理不当：多线程环境中未正确获取/释放GIL，导致Python对象被非法访问。CaptureOutput方法虽使用了using (Py.GIL())，但异步任务中可能存在GIL持有时间过长或释放不及时的问题。
Python对象生命周期错误：动态引用的Python对象（如stdout_capture、sys）未被正确释放，垃圾回收时触发内存冲突。尤其是Dispose方法中，PythonEngine.Shutdown()执行时可能仍有未释放的Python对象。
多次初始化/销毁PythonEngine：Python解释器的全局状态无法完全重置，多次启动关闭会导致内存泄漏或残留指针，触发访问违例。
版本不兼容：PythonNet版本与目标Python版本、C#运行时版本不匹配，导致底层调用错误。

预防措施

严格管理GIL：所有访问Python对象的代码必须包裹在using (Py.GIL())块中，异步任务中适当增加延迟（如await Task.Delay(100)），减少GIL竞争。
显式释放Python对象：对动态创建的Python对象使用using语句或手动调用Dispose()，确保不再使用时立即释放，避免持有全局引用。
避免多次重启PythonEngine：全局维护一个实例，直到应用退出时才调用Shutdown()；若需隔离，使用子进程方案。
检查版本兼容性：确保PythonNet版本与Python解释器、C#运行时版本完全兼容，优先使用最新稳定版。
优化垃圾回收：脚本执行前调用PythonEngine.Collect()手动触发垃圾回收，减少内存碎片；初始化时设置PythonEngine.EnableFinalizers = true，确保Python对象被正确回收。

内容的提问来源于stack exchange，提问作者Henry

C#中顺序执行Python脚本时如何正确重启PythonNet避免内存访问错误？

问题描述 #

相关代码片段 #

额外细节 #

具体问题 #

解决方案与分析 #

1. 正确重置/重启PythonNet的方法 #

2. 实现Python脚本的完全隔离 #

3. 随机访问违例的原因与预防 #