这种第三方库自带运行时导致的版本冲突坑，真的太让人头疼了——明明单独用都没问题，导入顺序一变就直接崩溃，排查起来还费劲儿。针对你遇到的PySide6和自定义模块的VC运行时冲突场景，我整理了几个可以提前检测并给出友好提示的方案，你可以根据自己的项目情况选：

方案一：用ctypes枚举已加载的VC运行时DLL版本 #

Windows系统可以通过Win32 API枚举当前进程里的所有DLL，我们可以用Python的ctypes调用这些API，找出已加载的VC运行时文件，检查它们的版本和来源路径。

比如写一个检测函数，在导入你的自定义模块前调用：

import ctypes
from ctypes import wintypes

def get_loaded_vcruntime_versions():
    # 绑定需要的Win32 API
    kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
    
    EnumProcessModules = kernel32.EnumProcessModules
    EnumProcessModules.argtypes = [wintypes.HMODULE, wintypes.HMODULE, wintypes.DWORD, wintypes.LPDWORD]
    EnumProcessModules.restype = wintypes.BOOL
    
    GetModuleFileNameW = kernel32.GetModuleFileNameW
    GetModuleFileNameW.argtypes = [wintypes.HMODULE, wintypes.LPWSTR, wintypes.DWORD]
    GetModuleFileNameW.restype = wintypes.DWORD
    
    version_dll = ctypes.WinDLL('version', use_last_error=True)
    GetFileVersionInfoSizeW = version_dll.GetFileVersionInfoSizeW
    GetFileVersionInfoSizeW.argtypes = [wintypes.LPCWSTR, wintypes.LPDWORD]
    GetFileVersionInfoSizeW.restype = wintypes.DWORD
    
    GetFileVersionInfoW = version_dll.GetFileVersionInfoW
    GetFileVersionInfoW.argtypes = [wintypes.LPCWSTR, wintypes.DWORD, wintypes.DWORD, wintypes.LPVOID]
    GetFileVersionInfoW.restype = wintypes.BOOL
    
    VerQueryValueW = version_dll.VerQueryValueW
    VerQueryValueW.argtypes = [wintypes.LPCVOID, wintypes.LPCWSTR, wintypes.LPVOID, wintypes.LPUINT]
    VerQueryValueW.restype = wintypes.BOOL
    
    # 获取当前进程的模块列表
    hprocess = kernel32.GetCurrentProcess()
    modules = (wintypes.HMODULE * 1024)()
    needed = wintypes.DWORD()
    if not EnumProcessModules(hprocess, modules, ctypes.sizeof(modules), ctypes.byref(needed)):
        return {}
    
    versions = {}
    for hmod in modules:
        if not hmod:
            break
        # 获取模块路径
        path_buf = ctypes.create_unicode_buffer(260)
        if GetModuleFileNameW(hmod, path_buf, ctypes.sizeof(path_buf)) == 0:
            continue
        path = path_buf.value
        # 只筛选VC运行时核心DLL
        if not (path.lower().endswith('vcruntime140.dll') or path.lower().endswith('vcruntime140_1.dll')):
            continue
        # 获取版本信息
        size = GetFileVersionInfoSizeW(path, None)
        if size == 0:
            continue
        buf = ctypes.create_string_buffer(size)
        if not GetFileVersionInfoW(path, 0, size, buf):
            continue
        # 解析版本号
        ver_info = wintypes.LPVOID()
        ver_len = wintypes.UINT()
        if VerQueryValueW(buf, u'\\', ctypes.byref(ver_info), ctypes.byref(ver_len)):
            ver_struct = ctypes.cast(ver_info, ctypes.POINTER(ctypes.c_uint * 4)).contents
            version = f"{ver_struct[0]}.{ver_struct[1]}.{ver_struct[2]}.{ver_struct[3]}"
            versions[path] = version
    return versions

# 检测逻辑示例
loaded_runtimes = get_loaded_vcruntime_versions()
# 替换成你的模块需要的最低VC运行时版本
min_required_version = (14, 36, 32532, 0)

for dll_path, version_str in loaded_runtimes.items():
    # 判断是否是PySide6自带的运行时
    if 'pyside6' in dll_path.lower():
        current_version = tuple(map(int, version_str.split('.')))
        if current_version < min_required_version:
            print("⚠️ 警告：已检测到PySide6加载的旧版本Visual C++运行时！")
            print("直接导入自定义模块会导致程序崩溃，请先导入你的模块再导入PySide6。")
            # 可以选择抛出异常终止程序，避免崩溃
            # raise RuntimeError("运行时版本不匹配，请调整导入顺序！")

这个方法不用修改你的C扩展代码，直接在Python层面就能完成检测，适合快速验证和临时修复。

方案二：自定义导入钩子自动检测 #

利用Python的importlib元路径钩子，在你的自定义模块被导入前自动触发检查，一旦发现冲突就抛出明确的错误，而不是让程序莫名其妙崩溃。

把前面的检测函数和钩子结合起来：

import sys
from importlib.abc import MetaPathFinder, Loader

# 先复制前面的get_loaded_vcruntime_versions函数到这里

class RuntimeConflictChecker(MetaPathFinder):
    def find_spec(self, fullname, path, target=None):
        # 只对你的自定义模块做检查
        if fullname == "your_custom_module":
            loaded_runtimes = get_loaded_vcruntime_versions()
            min_required = (14, 36, 32532, 0)
            has_old_pyside_runtime = False
            
            for dll_path, version_str in loaded_runtimes.items():
                if 'pyside6' in dll_path.lower():
                    ver_tuple = tuple(map(int, version_str.split('.')))
                    if ver_tuple < min_required:
                        has_old_pyside_runtime = True
                        break
            
            if has_old_pyside_runtime:
                raise ImportError("❌ 检测到PySide6已加载旧版本Visual C++运行时，请先导入your_custom_module再导入PySide6！")
        # 检查通过，交给默认导入机制处理
        return None

# 注册钩子，要放在导入你的模块之前
sys.meta_path.insert(0, RuntimeConflictChecker())

# 之后当有人尝试导入你的模块时，会自动检查
# import your_custom_module

这种方法适合集成到项目的初始化代码里，对用户完全透明，只要导入顺序不对就会立刻给出明确的错误提示。

方案三：在C扩展初始化时做检查 #

如果你的自定义模块是C++编写的扩展，可以直接在模块的初始化函数里加检测逻辑，在模块加载的最早期就拦截问题。

示例C++代码：

#include <Python.h>
#include <windows.h>
#include <vector>
#include <wchar.h>

// 检查是否加载了PySide6自带的旧版本VC运行时
BOOL IsOldPySideVCRuntimeLoaded() {
    HMODULE hRuntimeDll = GetModuleHandleW(L"vcruntime140.dll");
    if (!hRuntimeDll) return FALSE;
    
    WCHAR dllPath[MAX_PATH] = {0};
    GetModuleFileNameW(hRuntimeDll, dllPath, MAX_PATH);
    
    // 判断DLL是否来自PySide6目录
    if (wcsstr(dllPath, L"PySide6") == NULL) return FALSE;
    
    // 获取文件版本信息
    DWORD dummy;
    DWORD versionSize = GetFileVersionInfoSizeW(dllPath, &dummy);
    if (versionSize == 0) return FALSE;
    
    std::vector<BYTE> versionBuf(versionSize);
    if (!GetFileVersionInfoW(dllPath, 0, versionSize, versionBuf.data())) return FALSE;
    
    VS_FIXEDFILEINFO* fileVerInfo = nullptr;
    UINT verInfoLen = 0;
    if (!VerQueryValueW(versionBuf.data(), L"\\", (LPVOID*)&fileVerInfo, &verInfoLen)) return FALSE;
    
    // 对比版本，这里替换成你的模块需要的最低版本
    DWORD majorVer = HIWORD(fileVerInfo->dwFileVersionMS);
    DWORD minorVer = LOWORD(fileVerInfo->dwFileVersionMS);
    if (majorVer < 14 || (majorVer == 14 && minorVer < 36)) {
        return TRUE;
    }
    
    return FALSE;
}

PyMODINIT_FUNC PyInit_your_custom_module(void) {
    // 先检查运行时冲突
    if (IsOldPySideVCRuntimeLoaded()) {
        PyErr_SetString(PyExc_ImportError, "检测到PySide6已加载旧版本Visual C++运行时，请先导入your_custom_module再导入PySide6！");
        return NULL;
    }
    
    // 正常的模块初始化逻辑
    static PyModuleDef moduleDef = {
        PyModuleDef_HEAD_INIT,
        "your_custom_module",
        nullptr,
        -1,
        nullptr
    };
    return PyModule_Create(&moduleDef);
}

这种方法最直接，因为C扩展的初始化是在模块加载的第一阶段执行的，能在任何代码运行前就阻止冲突发生，错误提示也会直接显示在Python的导入报错里。

备注：内容来源于stack exchange，提问作者F.X.