C#集成YOLOv8目标检测：基于ONNX Runtime的端到端部署实战

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

如果你是一名C#开发者，正在寻找一种简单、高效且能直接集成到现有WinForm/WPF项目中的目标检测方案，那么这篇文章就是为你准备的。

过去，想在C#里跑AI模型，尤其是像YOLOv8这样的前沿目标检测模型，听起来像是一个“不可能的任务”。常见的路径是：用Python训练模型，然后通过复杂的HTTP服务、gRPC或者进程间通信与C#程序交互。这套方案不仅架构复杂、延迟高，还引入了额外的运维成本和故障点。对于工业质检、安防监控、智能零售等需要实时处理和高可靠性的场景，这种“拼接”方案往往捉襟见肘。

这篇文章的核心判断是：通过ONNX Runtime，将YOLOv8模型直接部署到C#应用程序中，是当前C#开发者集成AI能力最直接、最高效的路径，没有之一。它彻底绕开了语言壁垒，让C#程序能像调用本地库一样直接运行深度学习模型，实现真正的端到端集成。

你可能会担心：这会不会很难？需要精通深度学习框架吗？需要复杂的C++/CLI封装吗？答案是：完全不需要。整个过程清晰、标准化，核心代码可能不超过200行。本文将带你从零开始，在30分钟内，将一个预训练的YOLOv8模型集成到你的C#项目中，并完成图片和视频流的实时检测。我们将聚焦于最实用的工业级部署流程，避开学术研究的细枝末节，直击工程实现的核心。

1. 为什么C#开发者现在必须关注YOLOv8与ONNX Runtime？

在深入代码之前，我们需要先理解这个技术组合解决了什么根本问题，以及为什么它现在变得如此可行。

传统C# AI集成的痛点：

1. 技术栈割裂：AI模型用Python（PyTorch/TensorFlow），业务应用用C#。开发者需要维护两套环境、两种语言，团队协作成本高。
2. 性能瓶颈：进程间通信（IPC）或网络调用（HTTP/gRPC）会带来显著的延迟，对于需要30FPS甚至60FPS实时处理的工业视觉应用，这是不可接受的。
3. 部署复杂：需要分别部署Python服务和C#应用，增加了系统复杂度与故障风险。
4. 资源浪费：两套运行时（Python解释器与.NET CLR）并存，内存和CPU开销更大。

ONNX Runtime带来的范式转变：ONNX（Open Neural Network Exchange）是一个开放的模型格式标准。ONNX Runtime是一个高性能推理引擎，支持在多种平台和语言（包括C#）上直接运行ONNX模型。它的价值在于：

• 跨语言：模型一旦转换为ONNX格式，就可以被C++、C#、Python、Java等多种语言直接调用，打破了Python的垄断。
• 高性能：针对不同硬件（CPU/GPU）进行了深度优化，推理速度往往优于原框架。
• 轻量级：作为一个本地库（NuGet包）引入，无需部署完整的Python环境。

YOLOv8的优势：YOLOv8是Ultralytics公司推出的最新一代目标检测模型，在精度和速度上取得了很好的平衡。对于C#开发者而言，它的一个巨大优点是官方提供了极其便捷的模型导出功能，可以一键导出为ONNX格式，且导出的模型对输入输出的处理非常规范，大大降低了后续集成的难度。

因此，“YOLOv8 + ONNX Runtime + C#”这个技术栈，完美地将前沿的AI检测能力与成熟的C#工业开发生态融合在一起。你不再需要成为深度学习专家，只需要遵循标准的工程化步骤，就能将强大的视觉AI能力变为自己应用程序中的几行代码。

2. 核心概念与工作流程全景图

在动手之前，让我们快速厘清几个关键概念和整个工作流程，确保你不仅知道怎么做，还知道为什么这么做。

核心概念解析：

• YOLOv8模型：一个“.pt”文件，包含了训练好的神经网络权重和结构。我们无法直接在C#中使用它。
• ONNX格式：一个“.onnx”文件，是一种开放的、与框架无关的模型表示格式。它是我们转换的目标。
• ONNX Runtime：一个运行时引擎（以NuGet包Microsoft.ML.OnnxRuntime或Microsoft.ML.OnnxRuntime.Gpu的形式提供）。它负责加载.onnx文件，并在C#中执行模型推理。
• 推理（Inference）：指将输入数据（如图片）喂给模型，并得到输出结果（如边界框、类别、置信度）的过程。

端到端工作流程：整个流程可以分为清晰的四个阶段，下图展示了从模型准备到C#集成的完整路径：

flowchart TD A[开始: Python环境<br>与YOLOv8] --> B[阶段一: 模型准备<br>导出YOLOv8为ONNX格式] B --> C{阶段二: 环境搭建<br>创建C#项目并引入依赖} C --> D[安装ONNX Runtime NuGet包] C --> E[安装图像处理库<br>如 OpenCvSharp] D & E --> F[阶段三: 核心代码实现] subgraph F [核心代码实现] F1[图像预处理<br>缩放/归一化/转Tensor] --> F2[创建推理会话<br>InferenceSession] F2 --> F3[执行模型推理<br>session.Run] F3 --> F4[输出后处理<br>解析边框/过滤/画图] end F --> G[阶段四: 运行与验证<br>在WinForm/WPF中显示结果] G --> H[完成: 集成YOLOv8的<br>C#工业检测应用]

接下来，我们将严格按照这个流程，一步步实现它。

3. 环境准备：你需要准备什么？

工欲善其事，必先利其器。以下是完成本教程所需的全部环境，大部分都是标准的C#开发配置。

3.1 开发环境

• 操作系统：Windows 10/11，64位。本文以Windows为例，ONNX Runtime同样支持Linux和macOS。
• IDE：Visual Studio 2022。社区版即可。确保安装了“.NET桌面开发”工作负载。
• .NET版本：.NET 6.0 或 .NET 8.0（推荐）。我们创建控制台应用或WinForms/WPF应用均可。

3.2 Python环境（仅用于模型导出）

• Python：3.8或3.9版本。这是转换模型唯一需要Python的地方。
• Ultralytics库：用于导出YOLOv8模型。在命令行中安装：

  pip install ultralytics

• ONNX：可选，但建议安装，用于验证模型。

  pip install onnx

3.3 预训练模型我们将使用YOLOv8官方预训练模型，无需自己训练。你可以从Ultralytics官网下载，但更简单的方式是让代码自动下载。我们这里以中等尺寸的yolov8m.pt为例。

4. 第一阶段：模型准备与导出

这是整个流程中唯一需要接触Python的步骤，非常简单。

1. 创建导出脚本：新建一个Python文件，例如export_yolov8_to_onnx.py。
2. 编写导出代码：

   from ultralytics import YOLO # 加载预训练的YOLOv8模型 # 首次运行会自动从官网下载 yolov8m.pt model = YOLO('yolov8m.pt') # 导出模型为ONNX格式 # imgsz: 指定模型输入图片的尺寸，必须是32的倍数，常用640 # opset: ONNX算子集版本，12或更高版本兼容性较好 # simplify: 是否应用onnx-simplifier简化模型，推荐True success = model.export(format='onnx', imgsz=640, opset=12, simplify=True) if success: print("模型导出成功！生成文件：yolov8m.onnx") else: print("模型导出失败！")

3. 运行脚本：

   python export_yolov8_to_onnx.py

   运行成功后，你会在当前目录下得到yolov8m.onnx文件。这个文件就是我们后续在C#中需要使用的核心模型文件。

关键参数解释：

• imgsz=640：模型固定输入尺寸为640x640。无论原始图片多大，都需要先缩放到这个尺寸。
• simplify=True：对计算图进行优化，移除冗余算子，有时能提升推理速度，强烈建议开启。

至此，Python的任务就完成了。将生成的yolov8m.onnx文件复制到你的C#项目目录下（例如Assets/Models/）。

5. 第二阶段：创建C#项目与配置环境

现在，我们回到熟悉的Visual Studio。

1. 创建新项目：打开VS2022，新建一个“控制台应用”或“Windows窗体应用(.NET)”，项目名称如YoloV8CSharpDemo。
2. 添加NuGet包依赖：通过NuGet包管理器为项目安装以下两个核心库：
   • Microsoft.ML.OnnxRuntime：这是ONNX Runtime的CPU版本推理引擎。如果你有NVIDIA GPU并希望使用GPU加速，可以安装Microsoft.ML.OnnxRuntime.Gpu，但需要额外配置CUDA和cuDNN，本文为简化使用CPU版本。
   • OpenCvSharp4和OpenCvSharp4.runtime.win：这是OpenCV的C#封装，用于图像的加载、缩放、色彩转换和结果绘制。它是处理计算机视觉任务的事实标准。 在“程序包管理器控制台”中运行：

   Install-Package Microsoft.ML.OnnxRuntime Install-Package OpenCvSharp4 Install-Package OpenCvSharp4.runtime.win

3. 添加模型文件：将上一步导出的yolov8m.onnx文件添加到项目中。右键项目 -> 添加 -> 现有项，选择该文件。在属性面板中，将其“复制到输出目录”设置为“如果较新则复制”。这样在编译后，模型文件会自动出现在可执行文件旁边。

6. 第三阶段：核心代码实现与逐行解析

这是最核心的部分。我们将创建一个YoloV8Predictor类来封装所有推理逻辑。请跟随注释仔细理解每一步。

6.1 定义模型元数据和数据结构首先，我们定义一些常量和管理检测结果的类。

// YoloV8Predictor.cs using Microsoft.ML.OnnxRuntime; using Microsoft.ML.OnnxRuntime.Tensors; using OpenCvSharp; using System.Drawing; namespace YoloV8CSharpDemo { // 记录单次检测的结果 public class DetectionResult { public RectangleF BoundingBox { get; set; } // 边界框 (X, Y, Width, Height)，比例坐标 public string Label { get; set; } // 类别标签，如 "person", "car" public float Confidence { get; set; } // 置信度 (0~1) } public class YoloV8Predictor : IDisposable { // 模型固定输入尺寸 (必须与导出时设置的imgsz一致) private const int _imageSize = 640; // COCO数据集的80个类别名称 (YOLOv8预训练模型使用此数据集) private static readonly string[] _cocoLabels = { "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" }; private InferenceSession _session; private bool _disposed = false; // 构造函数：加载ONNX模型，创建推理会话 public YoloV8Predictor(string modelPath) { // SessionOptions可以配置线程数、执行引擎等。对于CPU，使用默认值即可。 var options = new SessionOptions(); _session = new InferenceSession(modelPath, options); } } }

6.2 图像预处理：将图片转换为模型需要的张量模型输入需要是固定尺寸、归一化后的张量。这是最容易出错的一步。

// 在YoloV8Predictor类中添加方法 private float[] PreprocessImage(Mat image) { // 1. 将BGR图像转换为RGB (OpenCV默认是BGR，模型需要RGB) Mat rgbImage = new Mat(); Cv2.CvtColor(image, rgbImage, ColorConversionCodes.BGR2RGB); // 2. 调整图像大小至640x640，并使用填充(padding)保持宽高比 int maxSize = _imageSize; int height = rgbImage.Height; int width = rgbImage.Width; // 计算缩放比例 float scale = Math.Min((float)maxSize / width, (float)maxSize / height); int newWidth = (int)(width * scale); int newHeight = (int)(height * scale); // 缩放图像 Mat resized = new Mat(); Cv2.Resize(rgbImage, resized, new Size(newWidth, newHeight)); // 3. 创建一张640x640的灰色画布，并将缩放后的图像置于中央 Mat padded = new Mat(maxSize, maxSize, MatType.CV_8UC3, new Scalar(114, 114, 114)); // 灰色填充 int dx = (maxSize - newWidth) / 2; int dy = (maxSize - newHeight) / 2; Rect roi = new Rect(dx, dy, newWidth, newHeight); resized.CopyTo(padded[roi]); // 4. 将图像数据从HWC [640,640,3] 转换为CHW [3,640,640] 格式，并归一化到[0,1] float[] inputTensor = new float[3 * maxSize * maxSize]; for (int c = 0; c < 3; c++) { for (int h = 0; h < maxSize; h++) { for (int w = 0; w < maxSize; w++) { // 获取像素值 (0~255) 并归一化 inputTensor[c * maxSize * maxSize + h * maxSize + w] = padded.At<Vec3b>(h, w)[c] / 255.0f; } } } // 释放临时Mat对象，避免内存泄漏 rgbImage.Dispose(); resized.Dispose(); padded.Dispose(); return inputTensor; }

6.3 执行推理与后处理模型输出是8400个预测框（对于640输入），我们需要从中筛选出有效的检测结果。

// 在YoloV8Predictor类中添加方法 public List<DetectionResult> Predict(Mat image, float confidenceThreshold = 0.5f, float iouThreshold = 0.5f) { // 1. 预处理图像 float[] inputData = PreprocessImage(image); var inputTensor = new DenseTensor<float>(inputData, new[] { 1, 3, _imageSize, _imageSize }); // 2. 准备输入容器 var inputs = new List<NamedOnnxValue> { NamedOnnxValue.CreateFromTensor("images", inputTensor) }; // 3. 执行模型推理 using IDisposableReadOnlyCollection<DisposableNamedOnnxValue> results = _session.Run(inputs); // 4. 获取输出数据 (YOLOv8 ONNX模型输出名为"output0") var outputTensor = results.First().AsTensor<float>(); var data = outputTensor.ToArray(); // 5. 解析输出维度 [1, 84, 8400] // 84 = 4(bbox) + 80(class probabilities) int dimensions = 84; // cx, cy, w, h + 80个类别的分数 int numPredictions = outputTensor.Dimensions[2]; // 8400 var detections = new List<DetectionResult>(); // 6. 遍历所有预测框 for (int i = 0; i < numPredictions; i++) { // 获取该预测框的84维向量 float[] prediction = new float[dimensions]; Array.Copy(data, i * dimensions, prediction, 0, dimensions); // 找到最大类别置信度及其索引 float maxConfidence = 0; int maxIndex = 0; for (int j = 4; j < dimensions; j++) { if (prediction[j] > maxConfidence) { maxConfidence = prediction[j]; maxIndex = j - 4; } } // 7. 应用置信度阈值过滤 if (maxConfidence < confidenceThreshold) continue; // 8. 解析边界框 (cx, cy, w, h) 是相对于640x640输入的比例坐标 float cx = prediction[0]; float cy = prediction[1]; float width = prediction[2]; float height = prediction[3]; // 转换为左上角坐标 (x1, y1) 和右下角坐标 (x2, y2)，比例坐标 float x1 = (cx - width / 2); float y1 = (cy - height / 2); float x2 = (cx + width / 2); float y2 = (cy + height / 2); // 9. 将比例坐标转换回原始图像坐标 // 注意：预处理时我们进行了缩放和填充，需要逆向计算 int origHeight = image.Height; int origWidth = image.Width; float scale = Math.Min((float)_imageSize / origWidth, (float)_imageSize / origHeight); int newWidth = (int)(origWidth * scale); int newHeight = (int)(origHeight * scale); int dx = (_imageSize - newWidth) / 2; int dy = (_imageSize - newHeight) / 2; // 从填充画布坐标映射回原始图像坐标 x1 = Math.Max(0, (x1 - dx) / scale); y1 = Math.Max(0, (y1 - dy) / scale); x2 = Math.Min(origWidth, (x2 - dx) / scale); y2 = Math.Min(origHeight, (y2 - dy) / scale); float boxWidth = x2 - x1; float boxHeight = y2 - y1; // 确保边界框有效 if (boxWidth <= 0 || boxHeight <= 0) continue; detections.Add(new DetectionResult { BoundingBox = new RectangleF(x1, y1, boxWidth, boxHeight), Label = _cocoLabels[maxIndex], Confidence = maxConfidence }); } // 10. 应用非极大值抑制(NMS)过滤重叠框 return ApplyNonMaxSuppression(detections, iouThreshold); } // 非极大值抑制实现 private List<DetectionResult> ApplyNonMaxSuppression(List<DetectionResult> detections, float iouThreshold) { // 按置信度降序排序 var sortedDetections = detections.OrderByDescending(d => d.Confidence).ToList(); var selected = new List<DetectionResult>(); while (sortedDetections.Any()) { // 取出置信度最高的检测框 var current = sortedDetections[0]; selected.Add(current); sortedDetections.RemoveAt(0); // 计算与剩余框的IoU，移除重叠度高的 sortedDetections = sortedDetections.Where(d => CalculateIoU(current.BoundingBox, d.BoundingBox) < iouThreshold ).ToList(); } return selected; } // 计算两个矩形框的交并比(IoU) private float CalculateIoU(RectangleF boxA, RectangleF boxB) { float x1 = Math.Max(boxA.Left, boxB.Left); float y1 = Math.Max(boxA.Top, boxB.Top); float x2 = Math.Min(boxA.Right, boxB.Right); float y2 = Math.Min(boxA.Bottom, boxB.Bottom); float interArea = Math.Max(0, x2 - x1) * Math.Max(0, y2 - y1); float boxAArea = boxA.Width * boxA.Height; float boxBArea = boxB.Width * boxB.Height; return interArea / (boxAArea + boxBArea - interArea); }

6.4 绘制检测结果最后，我们添加一个工具方法来将检测结果可视化在图片上。

// 在YoloV8Predictor类中添加方法 public Mat DrawPredictions(Mat image, List<DetectionResult> results) { Mat resultImage = image.Clone(); Random rnd = new Random(); foreach (var detection in results) { // 为每个类别生成一个随机但固定的颜色 int labelIndex = Array.IndexOf(_cocoLabels, detection.Label); var color = Scalar.FromRgb(rnd.Next(256), rnd.Next(256), rnd.Next(256)); // 绘制矩形框 var rect = detection.BoundingBox; Cv2.Rectangle(resultImage, new Point((int)rect.X, (int)rect.Y), new Point((int)(rect.X + rect.Width), (int)(rect.Y + rect.Height)), color, 2); // 准备标签文本 string labelText = $"{detection.Label}: {detection.Confidence:F2}"; // 计算文本大小和背景矩形 int baseline = 0; var textSize = Cv2.GetTextSize(labelText, HersheyFonts.HersheySimplex, 0.5, 1, out baseline); Cv2.Rectangle(resultImage, new Point((int)rect.X, (int)rect.Y - textSize.Height - 5), new Point((int)rect.X + textSize.Width, (int)rect.Y), color, -1); // -1 表示填充 // 绘制文本 Cv2.PutText(resultImage, labelText, new Point((int)rect.X, (int)rect.Y - 5), HersheyFonts.HersheySimplex, 0.5, Scalar.White, 1); } return resultImage; }

7. 第四阶段：运行与验证

现在，我们创建一个主程序来使用这个预测器。

7.1 控制台应用测试

// Program.cs using OpenCvSharp; namespace YoloV8CSharpDemo { internal class Program { static void Main(string[] args) { // 1. 指定模型路径 (确保yolov8m.onnx已复制到输出目录) string modelPath = @"Assets\Models\yolov8m.onnx"; // 或使用相对路径 "./yolov8m.onnx" // 2. 创建预测器 using var predictor = new YoloV8Predictor(modelPath); // 3. 加载测试图片 string imagePath = @"test.jpg"; // 替换为你的图片路径 if (!File.Exists(imagePath)) { Console.WriteLine($"测试图片不存在: {imagePath}"); Console.WriteLine("请准备一张包含常见物体（如人、车）的图片，并命名为'test.jpg'放在程序目录下。"); return; } using var image = Cv2.ImRead(imagePath); if (image.Empty()) { Console.WriteLine("无法加载图片！"); return; } Console.WriteLine($"开始推理，图片尺寸: {image.Width}x{image.Height}"); // 4. 执行预测并计时 var stopwatch = System.Diagnostics.Stopwatch.StartNew(); var results = predictor.Predict(image, confidenceThreshold: 0.5f); stopwatch.Stop(); Console.WriteLine($"推理完成！耗时: {stopwatch.ElapsedMilliseconds} ms"); Console.WriteLine($"检测到 {results.Count} 个目标："); foreach (var result in results) { Console.WriteLine($" - {result.Label} ({result.Confidence:P0}) at [{result.BoundingBox.X:F0}, {result.BoundingBox.Y:F0}, {result.BoundingBox.Width:F0}, {result.BoundingBox.Height:F0}]"); } // 5. 绘制并保存结果 using var resultImage = predictor.DrawPredictions(image, results); string outputPath = @"result.jpg"; Cv2.ImWrite(outputPath, resultImage); Console.WriteLine($"结果已保存至: {outputPath}"); // 6. (可选) 显示图片 Cv2.ImShow("Detection Result", resultImage); Cv2.WaitKey(0); // 等待按键 Cv2.DestroyAllWindows(); } } }

7.2 集成到WinForm/WPF中在WinForm中，你可以将结果显示在PictureBox控件中；在WPF中，可以使用Image控件。核心逻辑与上述控制台程序完全一致，只需将图像加载、结果显示部分替换为UI线程操作。你甚至可以开启一个后台线程，从工业相机SDK（如海康、大华）实时获取帧，并调用Predict方法，实现真正的实时工业检测系统。

8. 常见问题与排查思路

在实际运行中，你可能会遇到以下问题。这里提供一份快速排查清单。

9. 最佳实践与进阶建议

当你成功跑通基础Demo后，以下建议可以帮助你将这个方案应用到真实的工业项目中。

1. 模型选择与优化：

   • 模型尺寸：YOLOv8提供n, s, m, l, x不同尺寸的模型，在精度和速度间权衡。工业场景通常使用yolov8s或yolov8m。
   • 自定义训练：使用自己的数据集训练模型，以检测特定缺陷或零件。Ultralytics提供了简单的训练API，训练后同样可导出为ONNX。
   • 模型量化：使用ONNX Runtime的量化工具将FP32模型转换为INT8模型，可以大幅提升推理速度（通常2-3倍），对CPU尤其友好，精度损失通常很小。

2. 性能优化：

   • 批处理：如果一次处理多张图片，可以使用批处理模式。在导出模型时，将输入维度设置为batchsize, 3, 640, 640（如-1, 3, 640, 640表示动态批次）。
   • 异步处理：对于视频流或相机流，使用生产者-消费者模式，一个线程负责抓取帧，另一个线程池负责推理，避免掉帧。
   • 缓存会话：InferenceSession的创建开销较大，应作为单例或长时间存活的对象。

3. 工程化与部署：

   • 配置化管理：将模型路径、置信度阈值、IOU阈值等参数放在appsettings.json中，便于不同环境切换。
   • 日志与监控：记录每次推理的耗时、检测到的目标数量，便于性能监控和问题排查。
   • 异常处理：对图像加载失败、模型推理失败等场景做好异常捕获和降级处理（如返回空结果或使用上一次有效结果）。
   • 依赖打包：发布时，确保目标机器已安装相应的VC++运行时（ONNX Runtime依赖）。或者考虑使用独立部署。

4. 扩展到工业场景：

   • 与相机SDK集成：将上述Predict方法嵌入到海康、大华、Basler等相机SDK的回调函数中，实现实时流分析。
   • 结果上报：将检测结果（如缺陷类型、位置）通过MQTT、OPC UA或数据库接口上报给MES（制造执行系统）或SCADA（监控与数据采集）系统。
   • 触发与控制：根据检测结果，通过串口、网口发送指令控制机械臂、PLC或打标机进行分拣、剔除或标记。

通过本文的步骤，你已经掌握了将最先进的目标检测模型YOLOv8无缝集成到C#应用中的核心技能。这条技术路径清晰、直接，极大地降低了C#开发者进入AI视觉应用的门槛。接下来，你可以尝试使用自己的数据训练一个定制模型，或者将其集成到现有的生产线软件中，解决一个具体的质检或识别问题。真正的价值，始于将技术应用于实际场景的那一刻。

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