企业官网建设流程全解析

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Claude 随心用，限时 5 折。 👉 点击领海量免费额度

在工业自动化、安防监控、缺陷检测等场景中，实时、准确地识别图像或视频流中的特定目标是核心需求。传统的机器视觉方案往往依赖复杂的特征工程和大量规则，开发门槛高且泛化能力有限。而基于深度学习的 YOLO 系列模型，以其“You Only Look Once”的单阶段检测架构，在速度和精度之间取得了良好平衡，成为工业视觉领域的热门选择。

对于长期使用 C# 进行上位机、工业软件或桌面应用开发的工程师而言，一个常见的困境是：Python 生态拥有丰富的 AI 模型和训练工具，但如何将其无缝集成到以 C# 为核心的成熟工业软件体系中？手动重写模型推理代码不仅工作量巨大，且极易出错。幸运的是，ONNX（Open Neural Network Exchange）格式和 ONNX Runtime 推理引擎为解决这一难题提供了标准化的桥梁。通过将训练好的 YOLOv8 模型导出为 ONNX 格式，我们可以在 C# 环境中利用 ONNX Runtime 进行高效推理，无需关心底层框架是 PyTorch 还是 TensorFlow。

本文将带领你，一位可能对深度学习模型部署不甚熟悉的 C# 开发者，在 30 分钟内完成从零搭建一个 C# 控制台应用程序，集成 YOLOv8 模型，并对本地图片进行目标检测的全过程。你将理解 ONNX Runtime 的工作机制，掌握关键的图像预处理、模型推理和后处理步骤，并能够将这套流程迁移到你的 WPF、WinForms 甚至 .NET Core 后端服务中。

1. 理解核心组件：YOLOv8、ONNX 与 ONNX Runtime

在动手写代码之前，我们需要厘清几个关键概念，这能帮助你在遇到问题时知道该从哪里着手排查。

1.1 YOLOv8 模型：从训练到部署的形态转换

YOLOv8 是 Ultralytics 公司发布的最新 YOLO 系列模型，它提供了分类、检测、分割等多种任务的支持。对于目标检测，我们通常使用.pt格式的 PyTorch 模型文件。这个文件包含了模型的结构定义和训练好的权重参数。

然而，.pt文件是 PyTorch 框架特有的，无法直接在 C# 中加载。因此，部署的第一步是进行模型格式转换。我们需要将其转换为一种与框架无关的中间格式——ONNX。ONNX 格式的模型（.onnx文件）包含了完整的计算图结构、运算符和模型参数，可以被多种运行时环境识别和执行。

1.2 ONNX Runtime：跨平台的模型推理引擎

ONNX Runtime (ORT) 是一个高性能的推理引擎，专门用于执行 ONNX 格式的模型。它针对不同硬件（CPU、GPU）和平台（Windows, Linux, macOS）进行了优化。在 C# 项目中，我们通过 NuGet 包Microsoft.ML.OnnxRuntime或Microsoft.ML.OnnxRuntime.Gpu（如需 GPU 加速）来引用它。

ORT 在 C# 中的工作流程非常清晰：

1. 创建推理会话：加载.onnx模型文件，创建一个InferenceSession对象。这个会话会负责管理模型的生命周期和推理资源。
2. 准备输入数据：模型期望的输入是一个或多个多维数组（Tensor）。对于 YOLOv8，输入通常是一个形状为[1, 3, 640, 640]的浮点型张量，代表一批（1张）3通道（RGB）、尺寸为 640x640 的图像数据。我们必须将原始的System.Drawing.Bitmap或字节流转换成这个精确的格式。
3. 执行推理：调用会话的Run方法，传入输入数据。ORT 会在内部执行模型定义的所有计算。
4. 解析输出数据：模型会返回一个或多个输出张量。对于 YOLOv8 检测模型，输出通常是一个形状为[1, 84, 8400]的张量（具体维度可能因导出参数而异），其中包含了所有预测框的位置、置信度和类别概率。我们需要编写后处理代码，从这个密集的输出中解析出最终的边界框、类别和置信度。

1.3 为何选择此方案：平衡效率与生态

对于 C# 开发者，直接集成 ONNX Runtime 有以下几个显著优势：

• 无需 Python 环境：整个推理过程完全在 .NET 生态中完成，部署简单，避免了跨语言调用的复杂性和性能损耗。
• 高性能：ONNX Runtime 经过了深度优化，在 CPU 上也能获得不错的推理速度，如果机器配有 NVIDIA GPU，还可以通过 CUDA 后端获得显著的加速。
• 标准化：ONNX 是业界的开放标准，一次转换，可以在多种语言和平台上复用。
• 与现有 C# 代码无缝集成：检测结果可以直接用于更新 WPF 界面、触发 PLC 信号、存入数据库等，流程顺畅。

2. 环境准备与项目初始化

我们将使用 Visual Studio 2022 和 .NET 6+ 框架来创建项目。确保你的开发环境满足以下要求。

2.1 开发环境与工具清单

2.2 创建 C# 控制台项目

1. 打开 Visual Studio 2022，选择“创建新项目”。
2. 搜索并选择“控制台应用”（C#），点击“下一步”。
3. 为项目命名，例如YoloV8OnnxDemo，选择合适的位置，将“框架”下拉框选择为“.NET 6.0 (长期支持)”或更高版本。点击“创建”。
4. 项目创建成功后，在解决方案资源管理器中，右键点击项目名称，选择“管理 NuGet 程序包”。

2.3 安装必要的 NuGet 包

我们需要通过 NuGet 安装两个核心包：

• Microsoft.ML.OnnxRuntime：用于 CPU 推理。
• System.Drawing.Common：用于图像加载和处理（在 .NET Core/5+ 中需要单独安装）。

在 NuGet 包管理器的“浏览”选项卡中，搜索并安装这两个包。如果你有 NVIDIA GPU 并希望使用 GPU 加速，可以搜索安装Microsoft.ML.OnnxRuntime.Gpu，但这需要额外配置 CUDA 和 cuDNN 环境，本文为简化流程，先使用 CPU 版本。

安装完成后，你的项目文件.csproj中应该包含类似以下的引用：

<ItemGroup> <PackageReference Include="Microsoft.ML.OnnxRuntime" Version="1.16.3" /> <PackageReference Include="System.Drawing.Common" Version="8.0.4" /> </ItemGroup>

2.4 准备模型和测试资源

1. 获取 ONNX 模型：如果你有训练好的 YOLOv8.pt模型，可以使用 Ultralytics 的 Python 库进行导出：

   pip install ultralytics python -c "from ultralytics import YOLO; model = YOLO('yolov8n.pt'); model.export(format='onnx')"

   这将生成一个yolov8n.onnx文件。对于新手，也可以直接从可靠的模型仓库下载预转换好的yolov8n.onnx文件（例如 Ultralytics 的官方 GitHub Release 页面）。
2. 放置模型文件：在项目根目录下创建一个名为Models的文件夹。将下载或导出的yolov8n.onnx文件复制到这个文件夹中。
3. 放置测试图片：在项目根目录下创建一个名为Assets的文件夹。找一张包含清晰物体的图片（如test.jpg）放进去。
4. 设置模型文件属性：在解决方案资源管理器中，右键点击Models/yolov8n.onnx文件，选择“属性”。在“属性”面板中，将“复制到输出目录”设置为“如果较新则复制”。这样在编译运行时，模型文件会自动复制到输出目录（如bin/Debug/net6.0/Models/），确保程序能找到它。

至此，项目的基础结构已经搭建完成。

3. 构建 YOLOv8 推理核心类

我们将创建一个专门的类YoloV8Predictor来封装所有与模型推理相关的逻辑，包括图像预处理、推理执行和结果后处理。这符合单一职责原则，也便于后续维护和扩展。

3.1 定义模型元数据和数据结构

首先，在项目中创建一个新的类文件YoloV8Predictor.cs。在文件顶部，我们需要引入必要的命名空间：

using Microsoft.ML.OnnxRuntime; using Microsoft.ML.OnnxRuntime.Tensors; using System.Drawing; using System.Drawing.Imaging;

然后，在类内部定义一些常量和数据结构：

public class YoloV8Predictor : IDisposable { // 模型输入尺寸，YOLOv8 通常为 640x640 public const int ImageSize = 640; // 预训练的 COCO 数据集类别名（YOLOv8n 默认使用 80 类） private readonly string[] _classNames = 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" }; // ONNX Runtime 推理会话 private readonly InferenceSession _session; // 记录原始图片尺寸，用于将归一化的检测框坐标映射回原图 private Size _originalImageSize; }

同时，我们需要一个类来表示最终的检测结果：

public class Prediction { public RectangleF Rectangle { get; set; } // 边界框 (x, y, width, height) public string Label { get; set; } // 类别标签 public float Confidence { get; set; } // 置信度 public int ClassIndex { get; set; } // 类别索引 }

3.2 初始化推理会话

在YoloV8Predictor的构造函数中，我们加载 ONNX 模型并创建推理会话。

public YoloV8Predictor(string modelPath) { // 创建会话选项，可以在这里配置线程数、优化级别等 var sessionOptions = new SessionOptions(); // sessionOptions.AppendExecutionProvider_CPU(); // 默认使用CPU // 如果安装了 GPU 包，可以取消注释下行以使用GPU // sessionOptions.AppendExecutionProvider_CUDA(0); try { _session = new InferenceSession(modelPath, sessionOptions); Console.WriteLine($"模型加载成功。输入节点: {_session.InputMetadata.First().Key}, 形状: {string.Join(",", _session.InputMetadata.First().Value.Dimensions)}"); } catch (Exception ex) { throw new InvalidOperationException($"无法加载模型文件 '{modelPath}'。请检查文件路径和格式。", ex); } }

3.3 实现图像预处理

模型要求输入是归一化到 [0, 1] 区间的、尺寸为[1, 3, 640, 640]的float张量，且通道顺序为 RGB。我们需要将Bitmap转换为此格式。

private Tensor<float> PreprocessImage(Bitmap image) { _originalImageSize = image.Size; // 1. 调整图像大小，保持长宽比进行填充 var resized = ResizeImage(image, ImageSize, ImageSize, out float ratio, out PointF padding); // 2. 将 Bitmap 转换为 RGB 字节数组 var bitmapData = resized.LockBits(new Rectangle(0, 0, resized.Width, resized.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb); int bytesPerPixel = 3; // Format24bppRgb byte[] pixelData = new byte[bitmapData.Stride * resized.Height]; System.Runtime.InteropServices.Marshal.Copy(bitmapData.Scan0, pixelData, 0, pixelData.Length); resized.UnlockBits(bitmapData); // 3. 创建张量并填充数据 (形状: [1, 3, 640, 640]) var inputTensor = new DenseTensor<float>(new[] { 1, 3, ImageSize, ImageSize }); // 遍历每个像素，将 BGR 顺序转换为 RGB，并归一化到 [0, 1] for (int y = 0; y < ImageSize; y++) { for (int x = 0; x < ImageSize; x++) { int baseIndex = y * bitmapData.Stride + x * bytesPerPixel; // 注意：Format24bppRgb 在内存中是 BGR 顺序 float b = pixelData[baseIndex] / 255.0f; // Blue float g = pixelData[baseIndex + 1] / 255.0f; // Green float r = pixelData[baseIndex + 2] / 255.0f; // Red inputTensor[0, 0, y, x] = r; // 通道0: Red inputTensor[0, 1, y, x] = g; // 通道1: Green inputTensor[0, 2, y, x] = b; // 通道2: Blue } } return inputTensor; } // 调整图像大小并保持长宽比（填充到正方形） private Bitmap ResizeImage(Bitmap image, int targetWidth, int targetHeight, out float ratio, out PointF padding) { ratio = Math.Min((float)targetWidth / image.Width, (float)targetHeight / image.Height); var newWidth = (int)(image.Width * ratio); var newHeight = (int)(image.Height * ratio); padding = new PointF((targetWidth - newWidth) / 2.0f, (targetHeight - newHeight) / 2.0f); var resized = new Bitmap(targetWidth, targetHeight); using (var graphics = Graphics.FromImage(resized)) { graphics.Clear(Color.FromArgb(114, 114, 114)); // YOLO 常用的填充色 graphics.DrawImage(image, new Rectangle((int)padding.X, (int)padding.Y, newWidth, newHeight), new Rectangle(0, 0, image.Width, image.Height), GraphicsUnit.Pixel); } return resized; }

这段预处理代码是集成成功的关键之一。常见的错误包括：忘记归一化（导致结果异常）、通道顺序错误（BGR vs RGB，导致颜色识别偏差）、未处理填充导致坐标映射错误。

3.4 执行推理与解析输出

预处理后，我们将张量输入模型并获取原始输出。

public List<Prediction> Predict(Bitmap image) { // 1. 预处理 var inputTensor = PreprocessImage(image); var inputName = _session.InputMetadata.Keys.First(); // 2. 准备输入容器 var inputs = new List<NamedOnnxValue> { NamedOnnxValue.CreateFromTensor(inputName, inputTensor) }; // 3. 执行推理 using IDisposableReadOnlyCollection<DisposableNamedOnnxValue> results = _session.Run(inputs); // 4. 获取输出数据 var output = results.First().AsTensor<float>(); // 输出形状通常为 [1, 84, 8400] 或类似，其中 84 = 4(框坐标) + 1(置信度) + 80(类别数) // 5. 后处理：解析张量，应用置信度阈值和NMS var predictions = ParseOutput(output); // 6. 将检测框坐标从预处理后的图像空间映射回原始图像空间 return MapToOriginal(predictions); }

后处理ParseOutput和MapToOriginal是算法核心，涉及置信度过滤和非极大值抑制。这里提供一个简化版本：

private List<Prediction> ParseOutput(Tensor<float> output) { var predictions = new List<Prediction>(); // 假设输出形状为 [1, 84, 8400] int dimensions = output.Dimensions[1]; // 84 int numPredictions = output.Dimensions[2]; // 8400 float confidenceThreshold = 0.5f; // 置信度阈值 float iouThreshold = 0.45f; // NMS 的 IoU 阈值 for (int i = 0; i < numPredictions; i++) { // 获取该预测的置信度 float confidence = output[0, 4, i]; if (confidence < confidenceThreshold) continue; // 找到最大概率的类别 int classIndex = 0; float maxClassScore = 0; for (int c = 5; c < dimensions; c++) { float score = output[0, c, i]; if (score > maxClassScore) { maxClassScore = score; classIndex = c - 5; } } // 计算最终置信度 float finalScore = confidence * maxClassScore; if (finalScore < confidenceThreshold) continue; // 解析边界框 (cx, cy, w, h)，坐标是相对于 640x640 预处理图像的 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; float y1 = cy - height / 2; float x2 = cx + width / 2; float y2 = cy + height / 2; predictions.Add(new Prediction { Rectangle = new RectangleF(x1, y1, width, height), Confidence = finalScore, ClassIndex = classIndex, Label = _classNames[classIndex] }); } // 应用非极大值抑制 (NMS) 去除重叠框 return ApplyNms(predictions, iouThreshold); } private List<Prediction> ApplyNms(List<Prediction> boxes, float iouThreshold) { // 按置信度降序排序 var sortedBoxes = boxes.OrderByDescending(b => b.Confidence).ToList(); var selected = new List<Prediction>(); while (sortedBoxes.Count > 0) { var current = sortedBoxes[0]; selected.Add(current); sortedBoxes.RemoveAt(0); for (int i = sortedBoxes.Count - 1; i >= 0; i--) { if (CalculateIoU(current.Rectangle, sortedBoxes[i].Rectangle) > iouThreshold) { sortedBoxes.RemoveAt(i); } } } return selected; } // 计算交并比 private float CalculateIoU(RectangleF a, RectangleF b) { float areaA = a.Width * a.Height; float areaB = b.Width * b.Height; float x1 = Math.Max(a.Left, b.Left); float y1 = Math.Max(a.Top, b.Top); float x2 = Math.Min(a.Right, b.Right); float y2 = Math.Min(a.Bottom, b.Bottom); float intersectionArea = Math.Max(0, x2 - x1) * Math.Max(0, y2 - y1); float unionArea = areaA + areaB - intersectionArea; return unionArea > 0 ? intersectionArea / unionArea : 0; } // 将坐标从预处理图像空间映射回原始图像空间 private List<Prediction> MapToOriginal(List<Prediction> predictions) { float ratio = Math.Min((float)ImageSize / _originalImageSize.Width, (float)ImageSize / _originalImageSize.Height); int newWidth = (int)(_originalImageSize.Width * ratio); int newHeight = (int)(_originalImageSize.Height * ratio); float padX = (ImageSize - newWidth) / 2.0f; float padY = (ImageSize - newHeight) / 2.0f; foreach (var pred in predictions) { // 去除填充 var rect = pred.Rectangle; rect.X = (rect.X - padX) / ratio; rect.Y = (rect.Y - padY) / ratio; rect.Width /= ratio; rect.Height /= ratio; // 确保坐标不超出原图边界 rect.X = Math.Max(0, rect.X); rect.Y = Math.Max(0, rect.Y); rect.Width = Math.Min(_originalImageSize.Width - rect.X, rect.Width); rect.Height = Math.Min(_originalImageSize.Height - rect.Y, rect.Height); pred.Rectangle = rect; } return predictions; }

3.5 实现 IDisposable 接口

由于InferenceSession持有非托管资源，需要确保正确释放。

public void Dispose() { _session?.Dispose(); }

4. 编写主程序进行验证

现在，我们回到Program.cs文件，编写主程序来串联整个流程。

using System.Drawing; using System.Drawing.Imaging; class Program { static void Main(string[] args) { // 1. 定义路径 string modelPath = @"Models\yolov8n.onnx"; string imagePath = @"Assets\test.jpg"; string outputPath = @"Assets\test_output.jpg"; // 2. 检查文件是否存在 if (!File.Exists(modelPath)) { Console.WriteLine($"错误：未找到模型文件 '{modelPath}'。请将其放入项目下的 Models 文件夹。"); return; } if (!File.Exists(imagePath)) { Console.WriteLine($"错误：未找到测试图片 '{imagePath}'。请将其放入项目下的 Assets 文件夹。"); return; } // 3. 加载图片 Bitmap originalImage; try { originalImage = new Bitmap(imagePath); Console.WriteLine($"加载图片成功，尺寸：{originalImage.Width}x{originalImage.Height}"); } catch (Exception ex) { Console.WriteLine($"加载图片失败：{ex.Message}"); return; } // 4. 创建预测器并执行推理 List<Prediction> results; using (var predictor = new YoloV8Predictor(modelPath)) { try { var stopwatch = System.Diagnostics.Stopwatch.StartNew(); results = predictor.Predict(originalImage); stopwatch.Stop(); Console.WriteLine($"推理完成，耗时：{stopwatch.ElapsedMilliseconds} ms"); Console.WriteLine($"检测到 {results.Count} 个目标："); } catch (Exception ex) { Console.WriteLine($"推理过程中发生错误：{ex.Message}"); return; } } // 5. 打印结果并绘制到图片上 using (var graphics = Graphics.FromImage(originalImage)) { var font = new Font("Arial", 12, FontStyle.Bold); var brush = new SolidBrush(Color.Red); var pen = new Pen(Color.Red, 2); foreach (var pred in results) { Console.WriteLine($" - {pred.Label} ({pred.Confidence:F2}) 位置：[{pred.Rectangle.X:F0}, {pred.Rectangle.Y:F0}, {pred.Rectangle.Width:F0}, {pred.Rectangle.Height:F0}]"); // 绘制矩形框 graphics.DrawRectangle(pen, pred.Rectangle.X, pred.Rectangle.Y, pred.Rectangle.Width, pred.Rectangle.Height); // 绘制标签文本 string labelText = $"{pred.Label} {pred.Confidence:F2}"; graphics.DrawString(labelText, font, brush, pred.Rectangle.X, pred.Rectangle.Y - 20); } } // 6. 保存带检测结果的图片 try { originalImage.Save(outputPath, ImageFormat.Jpeg); Console.WriteLine($"结果图片已保存至：{Path.GetFullPath(outputPath)}"); } catch (Exception ex) { Console.WriteLine($"保存结果图片失败：{ex.Message}"); } Console.WriteLine("程序执行完毕。"); } }

5. 运行、验证与结果分析

现在，按下F5或点击“开始调试”运行程序。

5.1 预期输出与验证

如果一切顺利，你将在控制台看到类似以下的输出：

加载图片成功，尺寸：1920x1080 模型加载成功。输入节点: images, 形状: 1,3,640,640 推理完成，耗时：120 ms 检测到 3 个目标： - person (0.87) 位置：[450, 200, 180, 400] - car (0.92) 位置：[800, 300, 300, 150] - dog (0.78) 位置：[100, 400, 120, 180] 结果图片已保存至：C:\...\YoloV8OnnxDemo\bin\Debug\net6.0\Assets\test_output.jpg 程序执行完毕。

同时，在Assets文件夹下会生成一张test_output.jpg图片，上面用红色矩形框标出了检测到的物体及其标签和置信度。

5.2 关键检查点

1. 模型加载成功：控制台打印出输入节点名称和形状，确认 ONNX 文件被正确解析。
2. 推理耗时：首次推理可能稍慢（包含会话初始化），后续推理会快很多。CPU 上处理单张 640x640 图片通常在 100-300ms 之间，具体取决于 CPU 性能。
3. 检测结果合理：观察输出的类别和位置是否与图片内容相符。如果出现大量误检或漏检，可能是预处理（如归一化、通道顺序）或后处理（如置信度阈值、NMS 参数）设置不当。
4. 输出图片：打开生成的图片，确认边界框绘制正确，且坐标映射回原图后没有偏移。

6. 常见问题排查与解决方案

在实际集成过程中，你可能会遇到以下问题。这里提供排查思路。

6.1 模型加载失败

6.2 推理结果异常（无检测框或框位置错误）

6.3 性能问题

6.4 在 GUI 或服务中集成时的注意事项

• 线程安全：InferenceSession的Run方法是线程安全的，可以多线程调用。但最佳实践是为每个线程或每个长时间运行的任务创建独立的会话，以避免阻塞。
• GPU 支持：如需 GPU 加速，安装Microsoft.ML.OnnxRuntime.Gpu包，并确保系统已安装正确版本的 CUDA 和 cuDNN。然后在SessionOptions中调用sessionOptions.AppendExecutionProvider_CUDA(deviceId);。
• 动态批处理：如果需要对多张图片同时推理以提高吞吐量，需要将模型导出为支持动态批次（如[batch_size, 3, 640, 640]），并相应调整预处理代码来构建批次张量。

7. 从演示到工业应用：最佳实践与扩展方向

这个控制台演示项目是集成的起点。要将其用于实际的工业目标检测项目，还需要考虑以下方面。

7.1 工程化改进清单

1. 配置化管理：将模型路径、置信度阈值、IOU 阈值、输入尺寸等参数提取到appsettings.json配置文件中，便于不同环境切换。
2. 日志与监控：集成如 NLog 或 Serilog 等日志框架，记录模型加载状态、推理耗时、检测数量等信息，便于问题追踪和性能分析。
3. 异常处理与重试：对模型加载、图片读取、推理过程添加更健壮的异常处理，对于暂时性错误（如硬件资源紧张）可以考虑重试机制。
4. 资源池：对于高并发场景，可以预先创建多个InferenceSession实例组成资源池，避免频繁创建销毁的开销。
5. 输入验证：对输入的图片格式、大小、通道数进行验证，对不支持的格式进行转换或拒绝。

7.2 集成到现有系统

• WPF/WinForms 桌面应用：将YoloV8Predictor类封装为一个服务。在界面线程中，通过Task.Run将推理任务抛到后台线程执行，避免界面卡顿。推理完成后，使用Dispatcher.Invoke回到 UI 线程更新检测结果和画面。
• ASP.NET Core Web API：将预测器以 Singleton 或 Scoped 服务的形式注册到依赖注入容器中。在 Controller 中接收上传的图片文件，调用服务进行推理，并将检测结果（框坐标、类别）以 JSON 格式返回。
• 工业相机 SDK 集成：工业相机（如海康、大华、Basler）的 SDK 通常提供 C# 接口，可以实时获取图像帧（Bitmap或字节数组）。你需要做的就是将本演示中的Bitmap输入替换为相机回调函数中获取的图像数据，并可能需要在另一个线程中处理推理结果以触发后续的 PLC 控制或报警逻辑。

7.3 使用自定义训练的模型

1. 训练模型：使用 Ultralytics YOLOv8 和你的专属数据集进行训练，得到best.pt。
2. 导出 ONNX：使用model.export(format='onnx', imgsz=640)导出。注意导出时的imgsz参数需与训练时一致，且与 C# 代码中的ImageSize常量匹配。
3. 更新类别名：在 C# 代码中，将_classNames数组替换为你自己数据集的类别名称列表，顺序与训练时data.yaml中定义的顺序保持一致。
4. 调整后处理：如果你的模型输出维度发生变化（例如，类别数不是80），需要相应修改ParseOutput方法中解析类别得分的循环边界for (int c = 5; c < dimensions; c++)。

通过以上步骤，你已经掌握了在 C# 环境中集成 YOLOv8 进行目标检测的核心流程。关键在于理解 ONNX 模型的输入输出格式，并正确实现预处理和后处理。这套方法不仅适用于 YOLOv8，也为你将来集成其他 ONNX 格式的视觉模型（如分类、分割模型）打下了坚实的基础。在实际工业项目中，下一步的重点将是优化性能、提升系统稳定性，并将检测逻辑与具体的业务流程深度结合。

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Claude 随心用，限时 5 折。 👉 点击领海量免费额度