优化C#调用Python脚本：避免重复加载库与大文件，提升后续响应速度

你的核心需求是避免每次调用重复执行耗时的库加载和大文件读取，只重复执行算法逻辑。下面是三种靠谱的实现方式：

方法一：把Python改成常驻HTTP服务 #

让Python脚本启动后一直运行，先完成库加载和大文件读取，然后通过HTTP接口接收C#的请求，每次请求只跑算法逻辑。

Python端示例（用Flask快速搭建） #

import flask
import json
# 1. 加载外部库
import numpy as np  # 替换成你的实际库

# 2. 加载大文件（只执行一次）
large_dataset = np.load("large_file.npy")  # 替换成你的加载逻辑

app = flask.Flask(__name__)

@app.route('/run-algorithm', methods=['POST'])
def run_algorithm():
    # 接收C#传来的参数
    params = flask.request.get_json()
    # 3. 执行算法逻辑（每次请求都跑这部分）
    result = np.mean(large_dataset * params['multiplier'])  # 替换成你的算法
    return json.dumps({"result": float(result)})

if __name__ == '__main__':
    app.run(host='127.0.0.1', port=8000, debug=False)

C#端调用示例 #

using System;
using System.Net.Http;
using System.Text;
using Newtonsoft.Json;

class Program
{
    static readonly HttpClient _httpClient = new HttpClient();

    static async System.Threading.Tasks.Task Main(string[] args)
    {
        // 首次调用会等待Python加载完成，后续调用直接返回结果
        var response1 = await CallAlgorithm(2.0);
        Console.WriteLine(response1);
        
        var response2 = await CallAlgorithm(3.0);
        Console.WriteLine(response2);
    }

    static async System.Threading.Tasks.Task<string> CallAlgorithm(double multiplier)
    {
        var requestData = new { multiplier = multiplier };
        var jsonContent = new StringContent(
            JsonConvert.SerializeObject(requestData),
            Encoding.UTF8,
            "application/json"
        );
        var response = await _httpClient.PostAsync(
            "http://127.0.0.1:8000/run-algorithm",
            jsonContent
        );
        return await response.Content.ReadAsStringAsync();
    }
}

优缺点：实现简单，支持多并发，不用管进程通信细节；但需要额外维护HTTP服务，首次启动要等服务就绪。

方法二：通过标准输入输出保持Python进程 alive #

启动一次Python进程，保持输入输出管道打开，C#每次把参数通过标准输入传给Python，Python处理后通过标准输出返回结果，循环等待下一次请求。

Python端示例 #

import sys
import json
# 1. 加载外部库
import pandas as pd  # 替换成你的库

# 2. 加载大文件（只执行一次）
large_df = pd.read_csv("huge_file.csv")  # 替换成你的加载逻辑

def process(params):
    # 3. 算法逻辑
    return large_df[large_df['value'] > params['threshold']].count()['value']

# 循环读取输入，处理请求
for line in sys.stdin:
    line = line.strip()
    if not line:
        continue
    try:
        params = json.loads(line)
        result = process(params)
        # 返回结果，必须加换行并刷新缓冲区，否则C#读不到
        print(json.dumps({"result": int(result)}))
        sys.stdout.flush()
    except Exception as e:
        print(json.dumps({"error": str(e)}))
        sys.stdout.flush()

C#端调用示例 #

using System;
using System.Diagnostics;
using System.IO;
using Newtonsoft.Json;

class Program
{
    static Process _pythonProcess;

    static void Main(string[] args)
    {
        // 只启动一次Python进程
        StartPythonProcess(@"path\to\python.exe", @"path\to\your_script.py");

        // 首次调用（已加载好库和文件）
        var result1 = RunAlgorithm(new { threshold = 100 });
        Console.WriteLine(result1);
        
        // 后续调用，仅执行算法
        var result2 = RunAlgorithm(new { threshold = 200 });
        Console.WriteLine(result2);

        // 程序结束时关闭进程
        _pythonProcess.Kill();
    }

    static void StartPythonProcess(string pythonPath, string scriptPath)
    {
        _pythonProcess = new Process();
        _pythonProcess.StartInfo = new ProcessStartInfo(pythonPath, scriptPath)
        {
            RedirectStandardInput = true,
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            CreateNoWindow = true,
            UseShellExecute = false
        };
        _pythonProcess.Start();
    }

    static string RunAlgorithm(object paramsObj)
    {
        string jsonParams = JsonConvert.SerializeObject(paramsObj);
        _pythonProcess.StandardInput.WriteLine(jsonParams);
        _pythonProcess.StandardInput.Flush();
        // 读取一行结果
        return _pythonProcess.StandardOutput.ReadLine();
    }
}

优缺点：不需要额外网络服务，通信开销小；但要处理输入输出的格式和缓冲区问题，进程崩溃后得手动重启。

方法三：用Python.NET把Python嵌入C#进程 #

通过Python.NET库，在C#进程里直接加载Python解释器，一次性完成库导入和大文件加载，之后直接调用Python函数执行算法，完全是进程内调用，性能最好。

步骤 #

1. 在C#项目中安装NuGet包：Python.Runtime
2. 确保C#能找到Python安装目录（可以在代码里设置，或者把Python路径加到环境变量）

C#端示例 #

using System;
using Python.Runtime;

class Program
{
    static void Main(string[] args)
    {
        // 设置Python路径（替换成你的Python安装路径）
        Environment.SetEnvironmentVariable("PYTHONHOME", @"C:\Python39");
        Environment.SetEnvironmentVariable("PYTHONPATH", @"C:\Python39\Lib;C:\Python39\Lib\site-packages");

        // 初始化Python解释器（只做一次）
        PythonEngine.Initialize();

        using (Py.GIL())
        {
            // 导入你的Python模块
            dynamic scriptModule = Py.Import("your_script");
            
            // 加载大文件（只做一次）
            dynamic largeData = scriptModule.load_large_file(@"path\to\huge_file.csv");

            // 调用算法逻辑（多次调用）
            dynamic result1 = scriptModule.run_algorithm(largeData, 100);
            Console.WriteLine(result1.ToString());

            dynamic result2 = scriptModule.run_algorithm(largeData, 200);
            Console.WriteLine(result2.ToString());
        }

        // 关闭Python解释器
        PythonEngine.Shutdown();
    }
}

对应的Python脚本（拆分函数） #

import pandas as pd

def load_large_file(file_path):
    # 加载大文件逻辑
    return pd.read_csv(file_path)

def run_algorithm(large_data, threshold):
    # 算法逻辑
    return large_data[large_data['value'] > threshold].count()['value']

优缺点：进程内调用，性能最优，无跨进程开销；但需要配置Python环境，注意版本兼容性，C#和Python的类型转换要处理好。

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