C#集成YOLOv8目标检测：基于ONNX Runtime的工业视觉应用实践

这次我们来看一个对 C# 开发者非常友好的项目：如何将 YOLOv8 目标检测模型集成到 C# 应用程序中，特别是面向工业场景。很多开发者想在自己的上位机、MES 系统或质检软件里加入 AI 视觉能力，但往往被 Python 环境、复杂的部署和跨语言调用劝退。这个方案的核心思路是使用 ONNX Runtime，让 C# 能直接加载和推理 YOLOv8 模型，实现真正的零门槛集成。

最值得关注的是，整个过程不需要你精通 Python 或深度学习框架，甚至不需要 GPU。你只需要一个训练好的 YOLOv8 模型文件（.pt 或 .onnx），在 Visual Studio 里通过 NuGet 安装几个库，就能在纯 C# 环境下跑起目标检测。这对于需要开发稳定、可交付的工业客户端软件的 .NET 开发者来说，是一个高效且可靠的路径。

硬件门槛极低。由于 ONNX Runtime 支持 CPU 推理，你完全可以在没有独立显卡的工控机或普通服务器上运行。当然，如果你有 NVIDIA GPU 并配置了 CUDA，推理速度会得到显著提升。本文将带你完成从环境准备、模型转换、C# 项目集成到实际图片/视频检测的全流程，并重点解决 ONNX Runtime 加载 CUDA 失败等常见坑点，目标是让新手在 30 分钟内看到检测框画出来的效果。

1. 核心能力速览

2. 适用场景与使用边界

这个方案非常适合以下人群和场景：

• C#/.NET 桌面应用开发者：希望为现有的 WinForms、WPF 甚至 ASP.NET Core 应用增加视觉 AI 功能。
• 工业上位机/自动化软件工程师：需要将视觉检测模块嵌入到 PLC 通讯、数据采集、报表生成等既有工作流中。
• 项目交付团队：追求交付物的稳定性和易部署性，不希望客户环境包含复杂的 Python 和众多深度学习依赖。
• 教学与原型验证：想快速验证 YOLOv8 模型在特定场景下的效果，并希望以可执行程序的形式展示。

使用边界与注意事项：

1. 模型训练仍需 Python：本方案解决的是推理部署问题。模型的训练、导出、优化（如添加注意力机制）仍需在 Python 环境下完成。
2. 性能与灵活性权衡：相比在 Python 中使用 PyTorch 直接推理，ONNX Runtime 在 C# 中的调用会损失一些 PyTorch 特有的灵活操作（如动态修改模型）。但对于标准的、静态图结构的 YOLOv8 推理，性能几乎无损。
3. 版权与合规：用于工业检测的模型，其训练数据需确保合法授权，避免使用未经许可的敏感数据。部署时，注意 ONNX Runtime 的许可协议。
4. 硬件适配：虽然 CPU 可运行，但对于高分辨率、高帧率的实时视频流检测，GPU（CUDA）仍是保证性能的必要条件，需提前评估。

3. 环境准备与前置条件

在开始写 C# 代码之前，需要准备好“原材料”：模型和开发环境。

3.1 模型准备：从 .pt 到 .onnx

YOLOv8 的官方模型格式是.pt(PyTorch)，C# 无法直接使用。我们需要将其转换为 ONNX 格式。

1. 安装 Ultralytics 包：在 Python 环境中执行pip install ultralytics。
2. 转换模型：使用以下 Python 脚本，将你的模型（例如best.pt）导出为 ONNX。关键参数opset=12确保兼容性，simplify=True进行模型简化。

   from ultralytics import YOLO # 加载训练好的模型 model = YOLO('path/to/your/best.pt') # 导出为 ONNX 格式 model.export(format='onnx', opset=12, simplify=True, imgsz=640)

   执行后，你会得到best.onnx文件。这就是 C# 要用的模型文件。

3.2 开发环境准备

1. IDE：Visual Studio 2022（推荐）或 Visual Studio 2019。社区版免费。确保安装时勾选了“.NET 桌面开发”或“ASP.NET 和 Web 开发”工作负载。
2. .NET 版本：创建新项目时，选择.NET 6.0或更高版本（如 .NET 8.0）。它们对现代库的支持更好，部署也更方便。.NET Framework 4.6.1+ 也可行，但步骤略有不同。
3. ONNX Runtime 库：我们将通过 NuGet 包管理器安装，这是最方便的方式。

4. 创建 C# 项目与安装依赖

接下来，我们在 Visual Studio 中搭建项目骨架。

1. 新建项目：打开 Visual Studio，创建新项目。选择“控制台应用”（.NET 6+）或“Windows 窗体应用”（WinForms）等，根据你的需求定。这里以控制台应用为例，便于演示核心逻辑。
2. 通过 NuGet 安装必要包：在解决方案资源管理器中，右键点击项目 -> “管理 NuGet 程序包”。搜索并安装以下两个核心包：
   • Microsoft.ML.OnnxRuntime：这是 ONNX Runtime 的官方 C# 绑定。注意：如果你打算使用GPU（CUDA）进行加速推理，需要安装Microsoft.ML.OnnxRuntime.Gpu。如果只使用 CPU，安装Microsoft.ML.OnnxRuntime即可。
   • OpenCvSharp4和OpenCvSharp4.runtime.win：用于图像的读取、预处理（缩放、归一化）、绘制检测框等操作。这是处理图像输入输出的利器。 安装时，注意保持版本兼容。通常选择最新的稳定版本即可。

5. 核心推理代码拆解与实现

一切就绪，开始编写 C# 代码。我们将逻辑分为几个部分：模型加载、图像预处理、推理执行、后处理（解析输出并画框）。

5.1 定义模型输入输出与工具类

首先，定义一些常量和辅助方法。创建一个类，例如Yolov8OnnxRuntime。

using Microsoft.ML.OnnxRuntime; using Microsoft.ML.OnnxRuntime.Tensors; using OpenCvSharp; using System; using System.Collections.Generic; using System.Drawing; using System.Linq; public class Yolov8OnnxRuntime { // 模型相关常量 private const int _imageSize = 640; // YOLOv8 输入尺寸，与导出时imgsz一致 private InferenceSession _session; private readonly string[] _classNames; // 你的类别名称数组，例如 ["person", "car", "defect"] public Yolov8OnnxRuntime(string modelPath, string[] classNames) { // 初始化推理会话 // 如果想用GPU，SessionOptions可以配置为使用CUDA provider var options = new SessionOptions(); // 如果安装了Gpu包，可以启用CUDA（需确保环境有CUDA和cuDNN） // options.AppendExecutionProvider_CUDA(); _session = new InferenceSession(modelPath, options); _classNames = classNames; } }

5.2 图像预处理方法

YOLOv8 模型要求输入为[1, 3, 640, 640]形状的归一化张量（NCHW格式）。我们需要将任意尺寸的图片转换为此格式。

private float[] PreprocessImage(Mat image) { // 1. 将BGR图像转换为RGB Mat rgb = new Mat(); Cv2.CvtColor(image, rgb, ColorConversionCodes.BGR2RGB); // 2. 调整大小并保持长宽比填充（Letterbox） int maxSize = _imageSize; int targetWidth, targetHeight; float ratio = Math.Min((float)maxSize / rgb.Cols, (float)maxSize / rgb.Rows); targetWidth = (int)(rgb.Cols * ratio); targetHeight = (int)(rgb.Rows * ratio); Mat resized = new Mat(); Cv2.Resize(rgb, resized, new Size(targetWidth, targetHeight)); // 3. 创建640x640的黑色画布，并将resized图像居中放置 Mat padded = Mat.Zeros(maxSize, maxSize, MatType.CV_8UC3); int dx = (maxSize - targetWidth) / 2; int dy = (maxSize - targetHeight) / 2; Rect roi = new Rect(dx, dy, targetWidth, targetHeight); resized.CopyTo(padded[roi]); // 4. 将图像数据转换为float32，并归一化到[0,1] padded.ConvertTo(padded, MatType.CV_32FC3, 1.0 / 255.0); // 5. 将HWC格式转换为CHW格式，并展平为一维数组 var channels = padded.Split(); List<float> inputData = new List<float>(); for (int c = 0; c < 3; c++) { for (int h = 0; h < maxSize; h++) { for (int w = 0; w < maxSize; w++) { inputData.Add(channels[c].At<float>(h, w)); } } } // 释放临时Mat foreach (var ch in channels) ch.Dispose(); rgb.Dispose(); resized.Dispose(); padded.Dispose(); return inputData.ToArray(); }

5.3 执行推理与后处理

这是最核心的部分。YOLOv8 的 ONNX 模型输出是[1, 84, 8400]的形状（对于 640x640 输入）。我们需要解析这个张量，应用置信度阈值和 NMS（非极大值抑制）来得到最终的检测框。

public List<DetectionResult> Detect(Mat image, float confThreshold = 0.5f, float iouThreshold = 0.5f) { // 1. 预处理 var inputData = PreprocessImage(image); var inputTensor = new DenseTensor<float>(inputData, new[] { 1, 3, _imageSize, _imageSize }); // 2. 准备输入容器并运行推理 var inputs = new List<NamedOnnxValue> { NamedOnnxValue.CreateFromTensor("images", inputTensor) }; using var results = _session.Run(inputs); // 3. 获取输出张量 [1, 84, 8400] var outputTensor = results.First().AsTensor<float>(); var predictions = outputTensor.ToArray(); long[] shape = outputTensor.Dimensions.ToArray(); // [1, 84, 8400] // 4. 解析输出 int numClasses = _classNames.Length; int numPredictions = (int)shape[2]; // 8400 List<DetectionResult> detections = new List<DetectionResult>(); for (int i = 0; i < numPredictions; i++) { // 每个预测有84个值：cx, cy, w, h, 以及80个类别的置信度（COCO数据集） // 对于自定义模型，需要调整。这里假设前4个是框坐标，后面是类别分数。 float cx = predictions[i]; float cy = predictions[numPredictions + i]; float w = predictions[2 * numPredictions + i]; float h = predictions[3 * numPredictions + i]; // 找到最大类别分数 float maxScore = 0; int classId = 0; for (int c = 0; c < numClasses; c++) { float score = predictions[(4 + c) * numPredictions + i]; if (score > maxScore) { maxScore = score; classId = c; } } // 计算置信度（框的objectness * 类别概率，YOLOv8输出已融合，这里maxScore可视为最终置信度） float confidence = maxScore; if (confidence > confThreshold) { // 将中心点坐标转换为左上角坐标 float x1 = cx - w / 2; float y1 = cy - h / 2; float x2 = cx + w / 2; float y2 = cy + h / 2; detections.Add(new DetectionResult { BoundingBox = new RectangleF(x1, y1, w, h), Confidence = confidence, ClassId = classId, ClassName = _classNames[classId] }); } } // 5. 应用NMS过滤重叠框 return ApplyNMS(detections, iouThreshold); } // NMS 实现（简化版） private List<DetectionResult> ApplyNMS(List<DetectionResult> detections, float iouThreshold) { var sortedDetections = detections.OrderByDescending(d => d.Confidence).ToList(); List<DetectionResult> nmsResults = new List<DetectionResult>(); while (sortedDetections.Count > 0) { var current = sortedDetections[0]; nmsResults.Add(current); sortedDetections.RemoveAt(0); sortedDetections.RemoveAll(det => { float iou = CalculateIoU(current.BoundingBox, det.BoundingBox); return iou > iouThreshold; }); } return nmsResults; } // 计算IoU private float CalculateIoU(RectangleF a, RectangleF b) { float interArea = Math.Max(0, Math.Min(a.Right, b.Right) - Math.Max(a.Left, b.Left)) * Math.Max(0, Math.Min(a.Bottom, b.Bottom) - Math.Max(a.Top, b.Top)); float unionArea = a.Width * a.Height + b.Width * b.Height - interArea; return unionArea > 0 ? interArea / unionArea : 0; } // 检测结果类 public class DetectionResult { public RectangleF BoundingBox { get; set; } public float Confidence { get; set; } public int ClassId { get; set; } public string ClassName { get; set; } }

5.4 绘制检测结果

得到检测结果后，我们需要将其绘制到原图上。

public Mat DrawDetections(Mat image, List<DetectionResult> results) { Mat resultImage = image.Clone(); Random rnd = new Random(); Dictionary<int, Scalar> colorMap = new Dictionary<int, Scalar>(); foreach (var det in results) { if (!colorMap.ContainsKey(det.ClassId)) { // 为每个类别生成一个随机颜色 colorMap[det.ClassId] = new Scalar(rnd.Next(0, 256), rnd.Next(0, 256), rnd.Next(0, 256)); } var color = colorMap[det.ClassId]; // 注意：BoundingBox坐标是相对于640x640预处理图像的，需要映射回原图坐标 // 这里需要根据预处理时的letterbox参数进行逆变换，为简化，假设预处理是直接resize（非letterbox） // 实际使用时，需要将det.BoundingBox根据预处理时记录的缩放比例和填充偏移进行反算。 // 以下为简化示例（直接缩放）： float scaleX = (float)image.Width / _imageSize; float scaleY = (float)image.Height / _imageSize; Rect rect = new Rect( (int)(det.BoundingBox.X * scaleX), (int)(det.BoundingBox.Y * scaleY), (int)(det.BoundingBox.Width * scaleX), (int)(det.BoundingBox.Height * scaleY) ); // 画矩形框 Cv2.Rectangle(resultImage, rect, color, 2); // 添加标签文本 string label = $"{det.ClassName}: {det.Confidence:F2}"; int baseline; var textSize = Cv2.GetTextSize(label, HersheyFonts.HersheySimplex, 0.5, 1, out baseline); Cv2.Rectangle(resultImage, new Point(rect.X, rect.Y - textSize.Height - baseline), new Point(rect.X + textSize.Width, rect.Y), color, -1); Cv2.PutText(resultImage, label, new Point(rect.X, rect.Y - baseline), HersheyFonts.HersheySimplex, 0.5, Scalar.White, 1); } return resultImage; }

6. 功能测试与效果验证

现在，我们编写主程序来串联所有功能，进行实际测试。

6.1 单张图片测试

创建一个控制台应用程序的Main方法。

static void Main(string[] args) { // 1. 初始化检测器 string modelPath = @"path\to\your\best.onnx"; string[] classNames = { "class0", "class1", "defect" }; // 替换为你的实际类别 var detector = new Yolov8OnnxRuntime(modelPath, classNames); // 2. 读取测试图片 string imagePath = @"test_image.jpg"; using Mat image = Cv2.ImRead(imagePath, ImreadModes.Color); if (image.Empty()) { Console.WriteLine($"无法读取图片: {imagePath}"); return; } // 3. 执行检测 var results = detector.Detect(image, confThreshold: 0.5f); // 4. 打印结果 Console.WriteLine($"检测到 {results.Count} 个目标:"); foreach (var r in results) { Console.WriteLine($" {r.ClassName} - 置信度: {r.Confidence:F2}, 位置: [{r.BoundingBox.X:F0},{r.BoundingBox.Y:F0},{r.BoundingBox.Width:F0},{r.BoundingBox.Height:F0}]"); } // 5. 绘制并保存结果 using Mat resultImage = detector.DrawDetections(image, results); string outputPath = @"output_image.jpg"; Cv2.ImWrite(outputPath, resultImage); Console.WriteLine($"结果已保存至: {outputPath}"); // （可选）显示图片 // Cv2.ImShow("Detection Result", resultImage); // Cv2.WaitKey(0); }

6.2 摄像头实时视频流测试

对于工业现场，实时视频流检测是常见需求。我们可以利用 OpenCvSharp 的VideoCapture轻松实现。

static void RunCameraDetection() { string modelPath = @"path\to\your\best.onnx"; string[] classNames = { "person", "helmet", "no_helmet" }; // 示例：安全帽检测 var detector = new Yolov8OnnxRuntime(modelPath, classNames); // 打开摄像头（0为默认摄像头，或传入视频文件路径） using var capture = new VideoCapture(0); if (!capture.IsOpened()) { Console.WriteLine("无法打开摄像头"); return; } using var window = new Window("YOLOv8 Real-time Detection"); using Mat frame = new Mat(); while (true) { capture.Read(frame); if (frame.Empty()) break; // 执行检测（注意：实时检测需考虑性能，可降低检测频率或缩小输入尺寸） var results = detector.Detect(frame, confThreshold: 0.6f); // 绘制结果 using Mat displayFrame = detector.DrawDetections(frame, results); window.ShowImage(displayFrame); // 按ESC退出 if (Cv2.WaitKey(1) == 27) break; } }

6.3 批量图片处理

对于质检场景，经常需要处理一个文件夹内的所有图片。

static void BatchProcessImages(string inputFolder, string outputFolder) { string modelPath = @"path\to\your\best.onnx"; string[] classNames = { "ok", "ng" }; // 示例：良品/不良品分类 var detector = new Yolov8OnnxRuntime(modelPath, classNames); Directory.CreateDirectory(outputFolder); var imageFiles = Directory.GetFiles(inputFolder, "*.jpg"); foreach (var imageFile in imageFiles) { using Mat image = Cv2.ImRead(imageFile); if (image.Empty()) continue; var results = detector.Detect(image); using Mat resultImage = detector.DrawDetections(image, results); string outputFile = Path.Combine(outputFolder, Path.GetFileName(imageFile)); Cv2.ImWrite(outputFile, resultImage); Console.WriteLine($"已处理: {Path.GetFileName(imageFile)} -> 检测到 {results.Count} 个目标"); } Console.WriteLine("批量处理完成。"); }

7. 接口 API 与批量任务集成

对于更复杂的系统，你可能希望将检测功能封装成服务（如 Web API）供其他模块调用，或者管理一个批量任务队列。

7.1 封装为 Web API (ASP.NET Core)

创建一个 ASP.NET Core Web API 项目，将检测逻辑封装到控制器中。

1. 创建 API 项目：在 Visual Studio 中选择“ASP.NET Core Web API”模板。
2. 安装 NuGet 包：同样安装Microsoft.ML.OnnxRuntime和OpenCvSharp4。
3. 创建服务：创建一个单例服务IYoloDetectionService来加载和管理模型，避免每次请求都重新加载。

   // Services/IYoloDetectionService.cs public interface IYoloDetectionService { List<DetectionResult> Detect(byte[] imageData); } // Services/YoloDetectionService.cs public class YoloDetectionService : IYoloDetectionService { private readonly Yolov8OnnxRuntime _detector; public YoloDetectionService(IConfiguration configuration) { var modelPath = configuration["Yolo:ModelPath"]; var classNames = configuration.GetSection("Yolo:ClassNames").Get<string[]>(); _detector = new Yolov8OnnxRuntime(modelPath, classNames); } public List<DetectionResult> Detect(byte[] imageData) { using var ms = new MemoryStream(imageData); using var mat = Mat.FromStream(ms, ImreadModes.Color); return _detector.Detect(mat); } } // 在 Program.cs 中注册服务 // builder.Services.AddSingleton<IYoloDetectionService, YoloDetectionService>();

4. 创建控制器：

   // Controllers/DetectionController.cs [ApiController] [Route("api/[controller]")] public class DetectionController : ControllerBase { private readonly IYoloDetectionService _detectionService; public DetectionController(IYoloDetectionService detectionService) { _detectionService = detectionService; } [HttpPost("detect")] public IActionResult DetectImage(IFormFile file) { if (file == null || file.Length == 0) return BadRequest("请上传图片文件。"); using var ms = new MemoryStream(); file.CopyTo(ms); var imageData = ms.ToArray(); var results = _detectionService.Detect(imageData); return Ok(new { detections = results }); } }

   这样，前端或其他服务就可以通过发送 POST 请求到/api/detection/detect来调用检测功能。

7.2 实现批量任务队列

对于需要处理大量图片的离线任务，可以使用后台任务队列（如BackgroundService或 Hangfire）。

// 一个简单的后台任务示例 public class DetectionBackgroundService : BackgroundService { private readonly ILogger<DetectionBackgroundService> _logger; private readonly IYoloDetectionService _detectionService; private readonly Channel<string> _imageQueue; // 使用 System.Threading.Channels 作为队列 public DetectionBackgroundService(ILogger<DetectionBackgroundService> logger, IYoloDetectionService detectionService) { _logger = logger; _detectionService = detectionService; _imageQueue = Channel.CreateUnbounded<string>(); } // 外部调用此方法添加任务 public async Task QueueImageForDetectionAsync(string imagePath) { await _imageQueue.Writer.WriteAsync(imagePath); } protected override async Task ExecuteAsync(CancellationToken stoppingToken) { await foreach (var imagePath in _imageQueue.Reader.ReadAllAsync(stoppingToken)) { try { _logger.LogInformation($"开始处理图片: {imagePath}"); var imageBytes = await System.IO.File.ReadAllBytesAsync(imagePath, stoppingToken); var results = _detectionService.Detect(imageBytes); // 处理结果，例如保存到数据库或生成报告 _logger.LogInformation($"图片 {imagePath} 处理完成，检测到 {results.Count} 个目标。"); } catch (Exception ex) { _logger.LogError(ex, $"处理图片 {imagePath} 时出错。"); // 可以实现重试逻辑 } } } }

8. 资源占用与性能观察

这是决定方案能否落地的关键。我们需要关注内存、CPU和GPU的使用情况。

1. CPU 模式：

   • 内存占用：主要取决于模型大小（.onnx文件）和输入图片尺寸。一个标准的 YOLOv8n 模型（~6MB），处理 640x640 图片时，进程内存占用通常在 200MB - 500MB 之间。
   • CPU 使用率：单张图片推理时，会短暂占用一个逻辑核心的 100%。批量处理或视频流时，CPU 使用率会持续较高。建议：在工控机上，确保有足够的 CPU 余量给其他任务。
   • 推理速度：在主流桌面 CPU（如 i5-12400）上，YOLOv8n 单张图片推理时间约为 30-80 毫秒。模型越大（如 YOLOv8x），速度越慢。

2. GPU (CUDA) 模式：

   • 启用方式：安装Microsoft.ML.OnnxRuntime.Gpu包，并在创建InferenceSession时配置SessionOptions。

     var options = SessionOptions.MakeSessionOptionWithCudaProvider(); // 简便方法 // 或者 // options.AppendExecutionProvider_CUDA();

   • 显存占用：加载模型和进行推理会占用显存。YOLOv8n 模型本身很小，但 ONNX Runtime 和 CUDA 上下文也会占用一部分。总占用通常在 500MB - 1.5GB 左右，远低于原生 PyTorch。
   • 性能提升：GPU 推理速度通常是 CPU 的 5 倍甚至更高。对于实时视频流（>15 FPS），GPU 几乎是必须的。
   • 常见坑点：ONNX Runtime 加载 CUDA 失败。这通常是因为：
     • 系统未安装匹配的 CUDA 和 cuDNN。
     • 安装的Microsoft.ML.OnnxRuntime.Gpu版本与 CUDA 版本不匹配。请检查 NuGet 包详情页面的依赖说明。
     • 环境变量PATH中未包含 CUDA 的bin目录。

性能观察方法：

• 使用任务管理器（Windows）或nvidia-smi（Linux，需 GPU）观察 CPU/内存/GPU 使用率。
• 在代码中关键位置使用Stopwatch记录推理耗时。

  var sw = System.Diagnostics.Stopwatch.StartNew(); var results = detector.Detect(image); sw.Stop(); Console.WriteLine($"推理耗时: {sw.ElapsedMilliseconds} ms");

9. 常见问题与排查方法

10. 最佳实践与使用建议

1. 模型优化：在 Python 端导出 ONNX 模型时，可以尝试使用dynamic参数导出动态尺寸模型，以支持不同大小的输入。但对于性能要求高的场景，固定尺寸（如 640x640）通常效率更高。
2. 预热：在正式处理任务前，先用一张小图或空白图运行一次推理。这可以触发 JIT 编译和初始化，使后续推理速度稳定。
3. 资源管理：InferenceSession、Mat、Tensor都是非托管资源，务必使用using语句或在类析构时妥善释放，尤其是在 Web API 或长时间运行的服务中。
4. 错误处理与日志：在生产环境中，务必对图像读取、模型推理、文件保存等操作进行完善的try-catch，并记录详细的日志，便于排查线上问题。
5. 版本固化：记录项目成功运行时所依赖的 NuGet 包（Microsoft.ML.OnnxRuntime、OpenCvSharp4）的确切版本号，避免因自动升级导致的不兼容问题。
6. 部署打包：发布时，确保目标机器具备所需的运行时（如 .NET Runtime, VC++ Redistributable）。对于 GPU 版本，目标机器必须安装正确版本的 CUDA/cuDNN。可以考虑使用独立部署模式。

将 YOLOv8 通过 ONNX Runtime 集成到 C# 项目中，为 .NET 开发者打开了一扇通往本地 AI 视觉应用的大门。这个方案最大的优势在于部署简单和与现有 C# 技术栈的无缝融合。你不再需要维护一个独立的 Python 服务并通过进程间通信来调用，所有逻辑都内聚在同一个应用程序中。

最先应该验证的是模型的正确性：确保从 Python 导出的 ONNX 模型，在 C# 中用相同的预处理和后处理逻辑，能得到与 Python 环境一致的检测结果。这是所有后续工作的基石。最容易踩的坑集中在环境配置，尤其是 GPU 版本的 ONNX Runtime 对 CUDA 环境的苛刻要求。建议初期先使用 CPU 模式跑通全流程，再攻关 GPU 加速。

下一步，你可以探索更多高级特性，例如使用 YOLOv8 的 Pose、Segmentation 模型，或者将检测功能与你的具体业务逻辑（如数据库存储、PLC 控制信号触发、报表生成）深度集成。这个稳固的 C# 推理框架，将成为你开发智能工业软件的有力武器。