C#集成YOLOv8目标检测：基于ONNX Runtime的.NET AI应用开发指南

这次我们来看一个对 C# 开发者非常友好的项目：如何将 YOLOv8 目标检测模型集成到你的 .NET 应用程序中。如果你在做工业视觉、上位机软件或者任何需要本地图像分析的桌面应用，并且希望用 C# 直接调用高性能的 AI 模型，那么这篇文章就是为你准备的。

核心思路很直接：我们不依赖复杂的 Python 环境，而是通过 ONNX Runtime 这个跨平台推理引擎，在 C# 项目中直接加载和运行 YOLOv8 模型。这意味着你可以用 Visual Studio 开发一个纯粹的 .NET 应用（WinForm、WPF 甚至控制台程序），轻松实现图片或视频流的目标检测。整个过程对新手友好，从环境搭建到跑通第一个检测 demo，30 分钟足够。

本文将带你完成从零到一的完整流程。我们会重点解决几个关键问题：如何准备 ONNX 格式的 YOLOv8 模型、如何在 Visual Studio 中配置 ONNX Runtime 的 C# 包、如何编写预处理和后处理代码来适配 YOLOv8 的输出，以及最终如何将检测框和标签画到图片上。无论你是想为现有 C# 项目增加 AI 能力，还是单纯想学习如何在 .NET 生态中使用深度学习模型，这篇指南都能提供清晰的路径。

1. 核心能力速览

在深入代码之前，我们先快速了解这个方案的核心特性和要求，让你判断是否适合你的场景。

2. 适用场景与使用边界

这个方案完美契合那些核心业务逻辑用 C# 编写，但需要嵌入视觉 AI 功能的场景。

最适合谁？

• 工业上位机软件开发人员：需要将视觉检测模块集成到现有的 MES、SCADA 或设备控制软件中。
• 传统 C# 桌面应用开发者：希望为图片管理、安防监控等应用增加智能识别功能，而不想引入复杂的 Python 服务交互。
• 学生和研究者：想快速验证 YOLOv8 模型在特定 C# 应用中的效果，进行原型开发。

能解决什么问题？

1. 环境隔离：最终用户电脑无需安装 Python、PyTorch 等环境，一个 .exe 或安装包即可部署。
2. 性能可控：利用 ONNX Runtime 的优化，在 CPU 或 GPU 上获得稳定、高效的推理性能。
3. 无缝集成：检测逻辑直接以类库的形式存在于你的 C# 解决方案中，调用就像调用其他 .NET 库一样简单。
4. 快速原型：基于成熟的 YOLOv8 模型和 ONNX Runtime，开发者可以专注于业务逻辑，而非底层推理框架。

使用边界与注意事项

• 模型训练与导出：模型的训练、优化和导出为 ONNX 格式，仍需在 Python 环境下完成。本文会提供标准的导出命令。
• 复杂后处理：YOLOv8 的输出后处理（如非极大值抑制 NMS）需要在 C# 端实现。这是集成的主要编码工作，本文会提供完整代码。
• 功能限制：此方案主要用于推理（Inference）。如果你需要在线学习、模型微调等高级功能，此方案不适用。
• 版权与合规：确保你使用的 YOLOv8 模型（无论是预训练还是自定义训练）符合其开源协议（AGPL-3.0）。在工业场景中使用自定义训练的模型时，需确保训练数据拥有合法授权。

3. 环境准备与前置条件

让我们开始准备环境。你不需要高配显卡，从一台安装了 Windows 和 Visual Studio 的电脑开始就行。

3.1 基础软件环境

• 操作系统：Windows 10/11 (推荐)。也支持 Linux 和 macOS，但本文以 Windows + Visual Studio 为例。
• 开发 IDE：Visual Studio 2019 或 2022 (社区版即可)。确保安装了.NET 桌面开发工作负载。
• .NET 版本：项目目标框架建议选择.NET 6或.NET 8(长期支持版本)，它们对 ONNX Runtime 的支持更好。

3.2 获取 YOLOv8 ONNX 模型这是最关键的一步。你需要一个.onnx格式的 YOLOv8 模型文件。

1. 安装 Ultralytics YOLOv8 Python 包(只需一次)：

   pip install ultralytics

2. 导出模型：你可以导出官方的预训练模型，或者导出自己训练好的模型。
   • 导出预训练模型 (例如 yolov8s):

     from ultralytics import YOLO model = YOLO('yolov8s.pt') # 会自动下载 yolov8s.pt model.export(format='onnx') # 导出为 yolov8s.onnx

   • 导出自定义训练模型:

     from ultralytics import YOLO model = YOLO('path/to/your/best.pt') # 你训练好的模型 model.export(format='onnx', imgsz=640) # 指定导出图片尺寸

   导出的yolov8s.onnx文件就是我们 C# 项目需要的模型文件。将其复制到一个方便引用的位置，例如项目下的Models文件夹。

3.3 创建 C# 项目在 Visual Studio 中创建一个新的 C# 项目，类型可以是：

• 控制台应用：用于快速测试和验证。
• 类库：将检测功能封装成 DLL，供其他项目调用。
• WPF 或 WinForms 应用：用于开发带界面的演示程序。 本文以控制台应用为例进行说明。

4. 安装部署与启动方式

这里的“部署”指的是在 C# 项目中安装必要的 NuGet 包，并准备好模型文件。

4.1 安装 NuGet 包在 Visual Studio 中，通过“工具” -> “NuGet 包管理器” -> “管理解决方案的 NuGet 程序包”，为你的项目安装以下包：

• Microsoft.ML.OnnxRuntime：这是核心的 ONNX Runtime 推理库。注意：根据你的需求选择子包：
  • Microsoft.ML.OnnxRuntime：仅支持 CPU 推理。
  • Microsoft.ML.OnnxRuntime.Gpu：支持 CUDA 进行 GPU 加速 (需要 NVIDIA 显卡和对应 CUDA 驱动)。
  • Microsoft.ML.OnnxRuntime.DirectML：支持通过 DirectML 进行 GPU 加速 (适用于 AMD/Intel/NVIDIA GPU，Windows 10/11)。 对于新手和大多数场景，先安装Microsoft.ML.OnnxRuntime(CPU版本) 进行测试是最稳妥的。
• System.Drawing.Common：用于图片的加载、处理和绘制（在 .NET Core/5+ 中需要单独安装）。
• OpenCvSharp4或OpenCvSharp4.runtime.win(可选但推荐)：提供了比System.Drawing更强大、性能更好的计算机视觉图像处理功能，特别是视频流处理。安装它和对应的运行时包。

4.2 项目结构与模型放置建议的项目结构如下：

YourCSharpProject/ ├── Models/ │ └── yolov8s.onnx # 你的 ONNX 模型文件 ├── InputImages/ # 存放待检测的图片 ├── OutputImages/ # 存放检测后的图片 ├── Program.cs # 主程序 └── YoloPredictor.cs # 封装的 YOLO 预测类 (推荐)

在 Visual Studio 中，将yolov8s.onnx文件添加到项目里，并设置其“复制到输出目录”属性为“如果较新则复制”或“始终复制”。这样程序运行时能在输出目录找到模型文件。

5. 功能测试与效果验证

接下来是核心部分：编写 C# 代码来加载模型、处理图片、运行推理并解析结果。

5.1 创建 YOLO 预测器类 (YoloPredictor.cs)为了代码清晰和可复用，我们创建一个专门的类来处理 YOLOv8 推理。

using System; using System.Collections.Generic; using System.Drawing; using System.Linq; using Microsoft.ML.OnnxRuntime; using Microsoft.ML.OnnxRuntime.Tensors; public class YoloPredictor : IDisposable { private readonly InferenceSession _session; private readonly string[] _labels; // COCO数据集标签，自定义模型需替换 private readonly Size _modelSize = new Size(640, 640); // YOLOv8 默认输入尺寸 public YoloPredictor(string modelPath) { // 初始化推理会话。如需GPU，可使用 SessionOptions. var options = new SessionOptions(); // 如果安装了 GPU 包，可以启用 CUDA 或 DirectML // options.AppendExecutionProvider_CUDA(0); // 使用第一个CUDA设备 // options.AppendExecutionProvider_DML(0); // 使用DirectML _session = new InferenceSession(modelPath, options); // 加载COCO标签 (共80类) _labels = new string[] { "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch", "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush" }; } public List<Prediction> Predict(Image image, float confidenceThreshold = 0.5f, float iouThreshold = 0.45f) { // 1. 图片预处理：缩放、填充、归一化、转Tensor var (inputTensor, scaleFactor, pad) = PreprocessImage(image); // 2. 准备输入 var inputs = new List<NamedOnnxValue> { NamedOnnxValue.CreateFromTensor("images", inputTensor) }; // 3. 运行推理 using var results = _session.Run(inputs); var outputTensor = results.First().Value as Tensor<float>; // 4. 后处理：解析输出，应用NMS var predictions = Postprocess(outputTensor, scaleFactor, pad, confidenceThreshold, iouThreshold); return predictions; } private (DenseTensor<float>, float, (int, int)) PreprocessImage(Image image) { // 将Image转换为Bitmap并调整大小，保持长宽比进行填充 var bitmap = new Bitmap(image); var (resized, scaleFactor, pad) = ResizeAndPad(bitmap, _modelSize); // 将Bitmap数据转换为CHW格式的float数组，并归一化到[0,1] var input = new DenseTensor<float>(new[] { 1, 3, _modelSize.Height, _modelSize.Width }); for (int y = 0; y < resized.Height; y++) { for (int x = 0; x < resized.Width; x++) { var pixel = resized.GetPixel(x, y); input[0, 0, y, x] = pixel.R / 255.0f; // R input[0, 1, y, x] = pixel.G / 255.0f; // G input[0, 2, y, x] = pixel.B / 255.0f; // B } } resized.Dispose(); return (input, scaleFactor, pad); } private List<Prediction> Postprocess(Tensor<float> output, float scaleFactor, (int, int) pad, float confThreshold, float iouThreshold) { var predictions = new List<Prediction>(); // YOLOv8 ONNX 输出形状为 [1, 84, 8400] // 84 = 4(bbox) + 80(class scores) int dimensions = 84; // 4 box coordinates + 80 classes long numProposals = output.Dimensions[2]; // 8400 for (int i = 0; i < numProposals; i++) { // 找到最大类别分数 float maxScore = 0; int maxIndex = 0; for (int j = 4; j < dimensions; j++) { var score = output[0, j, i]; if (score > maxScore) { maxScore = score; maxIndex = j - 4; } } if (maxScore < confThreshold) continue; // 解析边界框 (cx, cy, w, h) 格式 float cx = output[0, 0, i]; float cy = output[0, 1, i]; float width = output[0, 2, i]; float height = output[0, 3, i]; // 转换为 (x1, y1, x2, y2) 格式，并映射回原图坐标 float x1 = (cx - width / 2 - pad.Item1) / scaleFactor; float y1 = (cy - height / 2 - pad.Item2) / scaleFactor; float x2 = (cx + width / 2 - pad.Item1) / scaleFactor; float y2 = (cy + height / 2 - pad.Item2) / scaleFactor; // 确保坐标在图片范围内 x1 = Math.Max(0, x1); y1 = Math.Max(0, y1); x2 = Math.Min(x2, _modelSize.Width / scaleFactor); // 原图宽度 y2 = Math.Min(y2, _modelSize.Height / scaleFactor); // 原图高度 predictions.Add(new Prediction { Box = new RectangleF(x1, y1, x2 - x1, y2 - y1), Score = maxScore, LabelIndex = maxIndex, LabelName = _labels[maxIndex] }); } // 应用非极大值抑制 (NMS) 去除重叠框 return ApplyNMS(predictions, iouThreshold); } // 简单的NMS实现 private List<Prediction> ApplyNMS(List<Prediction> boxes, float iouThreshold) { var sortedBoxes = boxes.OrderByDescending(b => b.Score).ToList(); var selected = new List<Prediction>(); while (sortedBoxes.Count > 0) { var current = sortedBoxes[0]; selected.Add(current); sortedBoxes.RemoveAt(0); sortedBoxes.RemoveAll(box => CalculateIoU(current.Box, box.Box) > iouThreshold); } return selected; } private float CalculateIoU(RectangleF a, RectangleF b) { var interArea = RectangleF.Intersect(a, b).Area; var unionArea = a.Area + b.Area - interArea; return unionArea > 0 ? interArea / unionArea : 0; } // 辅助方法：保持长宽比的缩放和填充 private (Bitmap, float, (int, int)) ResizeAndPad(Bitmap image, Size targetSize) { float scale = Math.Min((float)targetSize.Width / image.Width, (float)targetSize.Height / image.Height); var newWidth = (int)(image.Width * scale); var newHeight = (int)(image.Height * scale); var resized = new Bitmap(targetSize.Width, targetSize.Height); using (var g = Graphics.FromImage(resized)) { g.Clear(Color.FromArgb(114, 114, 114)); // YOLO 常用的填充色 int x = (targetSize.Width - newWidth) / 2; int y = (targetSize.Height - newHeight) / 2; g.DrawImage(image, x, y, newWidth, newHeight); } return (resized, scale, (x, y)); } public void Dispose() { _session?.Dispose(); } } public class Prediction { public RectangleF Box { get; set; } public float Score { get; set; } public int LabelIndex { get; set; } public string LabelName { get; set; } }

5.2 编写主程序进行测试 (Program.cs)现在，在Main方法中调用这个预测器。

using System; using System.Drawing; using System.Drawing.Imaging; using System.IO; class Program { static void Main(string[] args) { // 1. 路径配置 string modelPath = @".\Models\yolov8s.onnx"; string inputImagePath = @".\InputImages\test.jpg"; string outputImagePath = @".\OutputImages\result.jpg"; // 2. 确保输出目录存在 Directory.CreateDirectory(Path.GetDirectoryName(outputImagePath)); // 3. 加载图片 if (!File.Exists(inputImagePath)) { Console.WriteLine($"输入图片不存在: {inputImagePath}"); return; } using var image = Image.FromFile(inputImagePath); // 4. 创建预测器并执行检测 using var predictor = new YoloPredictor(modelPath); var predictions = predictor.Predict(image, confidenceThreshold: 0.5f); // 5. 在图片上绘制检测结果 using var bitmap = new Bitmap(image); using var graphics = Graphics.FromImage(bitmap); using var font = new Font("Arial", 12, FontStyle.Bold); using var brush = new SolidBrush(Color.Red); using var pen = new Pen(Color.Red, 2); Console.WriteLine($"检测到 {predictions.Count} 个目标:"); foreach (var pred in predictions) { Console.WriteLine($" {pred.LabelName}: {pred.Score:F2} at [{pred.Box.X:F0}, {pred.Box.Y:F0}, {pred.Box.Width:F0}, {pred.Box.Height:F0}]"); // 画框 graphics.DrawRectangle(pen, pred.Box.X, pred.Box.Y, pred.Box.Width, pred.Box.Height); // 画标签背景和文字 string labelText = $"{pred.LabelName} {pred.Score:F2}"; var labelSize = graphics.MeasureString(labelText, font); graphics.FillRectangle(Brushes.Red, pred.Box.X, pred.Box.Y - labelSize.Height, labelSize.Width, labelSize.Height); graphics.DrawString(labelText, font, Brushes.White, pred.Box.X, pred.Box.Y - labelSize.Height); } // 6. 保存结果图片 bitmap.Save(outputImagePath, ImageFormat.Jpeg); Console.WriteLine($"结果已保存至: {outputImagePath}"); Console.WriteLine("按任意键退出..."); Console.ReadKey(); } }

5.3 运行与验证

1. 将一张测试图片（如test.jpg）放入项目的InputImages文件夹。
2. 在 Visual Studio 中按F5运行程序。
3. 观察控制台输出，会打印检测到的目标类别、置信度和坐标。
4. 在OutputImages文件夹中查看生成的result.jpg，检测框和标签应已绘制在图片上。

判断成功的标准：

• 程序无报错，正常执行完毕。
• 控制台打印出合理的检测结果（例如，一张街景图能识别出car,person等）。
• 输出的图片上正确绘制了边界框和标签。

常见失败原因：

• 模型路径错误：确保yolov8s.onnx文件已复制到输出目录的Models文件夹下。
• NuGet 包未正确安装：检查Microsoft.ML.OnnxRuntime包是否安装成功。
• 图片预处理不一致：确保 C# 端的预处理（缩放、填充、归一化）与 Python 导出模型时的设置一致。上述代码已匹配 YOLOv8 官方的导出默认值。
• 后处理逻辑错误：如果检测框错位，重点检查Postprocess方法中坐标转换和缩放因子的计算。

6. 接口 API 与批量任务

将检测功能封装成类后，很容易扩展到其他场景，例如提供 Web API 或处理批量图片。

6.1 封装为 Web API 服务你可以创建一个 ASP.NET Core Web API 项目，将YoloPredictor封装为一个单例服务，并提供检测接口。

// 在 Startup.cs 或 Program.cs 中注册服务 builder.Services.AddSingleton<YoloPredictor>(sp => { var modelPath = builder.Configuration["ModelPath"]; return new YoloPredictor(modelPath); }); // 创建控制器 [ApiController] [Route("api/[controller]")] public class DetectionController : ControllerBase { private readonly YoloPredictor _predictor; public DetectionController(YoloPredictor predictor) => _predictor = predictor; [HttpPost("detect")] public async Task<IActionResult> DetectImage(IFormFile file) { if (file == null || file.Length == 0) return BadRequest("No file uploaded."); using var stream = new MemoryStream(); await file.CopyToAsync(stream); using var image = Image.FromStream(stream); var predictions = _predictor.Predict(image); // 将结果转换为DTO返回 var result = predictions.Select(p => new { label = p.LabelName, confidence = p.Score, x = p.Box.X, y = p.Box.Y, width = p.Box.Width, height = p.Box.Height }).ToList(); return Ok(result); } }

6.2 实现批量图片处理对于工业场景下的批量检测，可以遍历文件夹进行处理。

public void ProcessBatch(string inputFolder, string outputFolder, float confidenceThreshold = 0.5f) { Directory.CreateDirectory(outputFolder); var imageExtensions = new[] { ".jpg", ".jpeg", ".png", ".bmp" }; var imageFiles = Directory.GetFiles(inputFolder) .Where(f => imageExtensions.Contains(Path.GetExtension(f).ToLower())); using var predictor = new YoloPredictor("yolov8s.onnx"); foreach (var imagePath in imageFiles) { try { using var image = Image.FromFile(imagePath); var predictions = predictor.Predict(image, confidenceThreshold); // 绘制并保存结果 using var bitmap = new Bitmap(image); using var graphics = Graphics.FromImage(bitmap); // ... 绘制逻辑（同上）... string outputPath = Path.Combine(outputFolder, Path.GetFileName(imagePath)); bitmap.Save(outputPath, ImageFormat.Jpeg); Console.WriteLine($"Processed: {imagePath} -> {outputPath}"); } catch (Exception ex) { Console.WriteLine($"Error processing {imagePath}: {ex.Message}"); // 可加入重试机制或记录到日志文件 } } }

7. 资源占用与性能观察

理解资源消耗对于部署至关重要。

7.1 如何观察资源占用

• 任务管理器：运行程序后，打开任务管理器，在“性能”选项卡中查看 CPU、内存和 GPU（如果使用）的使用情况。
• 代码级监控：可以使用System.Diagnostics命名空间下的Process类来获取当前进程的内存占用。

7.2 CPU vs GPU 推理

• CPU 推理：通用性强，无需额外硬件，适合部署在没有独立显卡的工控机上。YOLOv8s 模型处理单张 640x640 图片，在主流 CPU 上耗时约 100-300 毫秒。内存占用主要取决于模型大小和图片批量。
• GPU 推理：速度可提升 5-20 倍。需要安装对应的Microsoft.ML.OnnxRuntime.Gpu包和正确的 CUDA/cuDNN 驱动。在代码中启用SessionOptions.AppendExecutionProvider_CUDA(0)。显存占用会比内存占用略高。

7.3 影响性能的关键参数

1. 模型尺寸：yolov8n(纳米) 最快，yolov8x(超大) 最准但最慢。工业场景下yolov8s或yolov8m是精度和速度的较好平衡。
2. 输入图片分辨率：导出模型时固定的imgsz参数（默认640）。分辨率越高，精度可能提升，但计算量呈平方增长。不要随意更改。
3. 置信度阈值 (confidenceThreshold)：值越高，返回的检测框越少，后处理稍快。根据实际需求调整。
4. NMS 阈值 (iouThreshold)：值越小，去除的重叠框越多。通常保持默认 0.45 即可。

7.4 降低资源占用的技巧

• 使用更小的模型：如yolov8n。
• 降低推理图片的分辨率：在导出模型时使用更小的imgsz（如 320），但这会重新训练或影响精度。
• 批量处理优化：ONNX Runtime 支持批量输入。如果你有多张图片，可以拼成一个 Batch 一次性推理，比循环单张处理更高效（需要修改预处理和模型输入）。
• 启用 GPU：如果硬件允许，这是提升吞吐量最有效的方式。

8. 常见问题与排查方法

集成过程中可能会遇到一些问题，下表列出了常见现象和解决方案。

9. 最佳实践与使用建议

遵循以下建议，可以让你在工业环境中更稳定、高效地使用此方案。

1. 第一次部署先做冒烟测试：用一张简单的、包含明显目标的图片进行测试，验证整个流程是否跑通。
2. 建立模型版本管理：当模型更新时，ONNX 文件可能变化。在代码或配置中记录模型版本，避免混淆。
3. 分离配置：将模型路径、置信度阈值、NMS 阈值等参数放在appsettings.json配置文件中，便于不同环境（开发、测试、生产）切换。
4. 加入日志和监控：在YoloPredictor的关键步骤（加载模型、推理、后处理）加入日志记录。监控每次推理的耗时，便于性能分析和预警。
5. 处理异常和重试：在批量处理或 API 服务中，对图像解码失败、推理超时等异常进行捕获和处理，必要时加入重试机制。
6. 注意线程安全：InferenceSession本身不是线程安全的。如果在多线程环境（如 Web API）中使用，需要加锁或为每个线程创建独立的会话（注意资源消耗）。更推荐使用依赖注入将其注册为单例，并在内部实现线程安全的调用。
7. 合规性检查：在工业应用中使用时，确保你的训练数据、模型用途符合相关法规和客户协议。对检测结果进行人工抽样复核，确保 AI 决策的可靠性。

10. 总结与下一步

通过本文的步骤，你应该已经成功在 C# 环境中集成了 YOLOv8 目标检测模型。整个过程的核心在于利用 ONNX Runtime 这座桥梁，将 Python 生态中强大的 YOLOv8 模型无缝对接到 .NET 世界。

最值得尝试的点：

• 极低的集成门槛：无需部署 Python 服务，纯 C# 项目即可完成。
• 灵活的性能选择：支持从 CPU 到 GPU 的多种推理后端，适应不同硬件环境。
• 完整的控制力：从图片预处理到结果绘制，整个流程都在你的 C# 代码控制之下，便于定制和调试。

最先应该验证的功能：

1. 使用官方yolov8s.onnx模型跑通单张图片检测。
2. 尝试切换到自己的自定义训练模型。
3. 在批量图片处理任务中测试其稳定性和速度。

最容易踩的坑：

• 预处理/后处理不一致：这是 90% 问题的根源。务必确保你的 C# 预处理逻辑与 YOLOv8 官方 Python 推理保持一致。
• 模型文件路径：相对路径在开发和生产环境中可能不同，建议使用配置文件或绝对路径。
• 对象释放：不释放Bitmap,Graphics,InferenceSession会导致内存泄漏。

后续扩展方向：

• 实时视频流：结合OpenCvSharp捕获摄像头或视频文件帧，进行实时检测。
• 多模型管理：开发一个模型管理器，支持热加载和切换不同的 ONNX 模型（如分类、分割模型）。
• 集成到 UI 框架：在 WPF 或 WinForms 中实现一个实时预览窗口，将检测结果动态绘制到控件上。
• 性能优化：探索 ONNX Runtime 的更多 Session 配置选项，如线程数设置、图优化等级等，进一步压榨性能。

这套方案为 C# 开发者打开了本地视觉 AI 应用的大门。建议将核心的YoloPredictor类封装成独立的类库，方便在未来的多个项目中复用。当你熟悉了这个流程后，集成其他 ONNX 格式的视觉模型（如 YOLOv9、RT-DETR 或 SAM 分割模型）也将变得轻而易举。