Form1Loading.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using ImageMagick;
using Svg;
using GdiPixelFormat = System.Drawing.Imaging.PixelFormat;

namespace LinView
{
    public partial class Form1
    {
        /// <summary>异步解码触发阈值：50MB</summary>
        private const long ASYNC_DECODE_THRESHOLD_BYTES = 50L * 1024 * 1024;

        /// <summary>从指定路径加载图片，并扫描同目录其他图片用于翻页。</summary>
        private void LoadImage(string filePath)
        {
            try
            {
                var dir = Path.GetDirectoryName(filePath);
                if (!string.IsNullOrEmpty(dir))
                {
                    var files = Directory.GetFiles(dir)
                        .Where(f => SupportedExtensions.Contains(Path.GetExtension(f).ToLowerInvariant()));

                    // 自然排序（图1、图2、图10）或普通字符串排序
                    if (_settings.UseNaturalSort)
                    {
                        _imageFiles = files
                            .OrderBy(f => Path.GetFileName(f), new NaturalStringComparer())
                            .ToArray();
                    }
                    else
                    {
                        _imageFiles = files.OrderBy(f => f).ToArray();
                    }

                    _currentIndex = Array.FindIndex(_imageFiles,
                        f => string.Equals(f, filePath, StringComparison.OrdinalIgnoreCase));
                }

                DisplayCurrentImage();
            }
            catch (Exception ex)
            {
                LogHelper.Write(ex, "LoadImage");
                MessageBox.Show($"打开图片失败：{ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>同步加载当前图片。</summary>
        private Bitmap LoadImageBitmap(string filePath)
        {
            string ext = Path.GetExtension(filePath).ToLowerInvariant();

            StopAndDisposeGif();

            if (ext == ".gif")
            {
                try
                {
                    return LoadGif(filePath);
                }
                catch (Exception ex)
                {
                    LogHelper.Write(ex, "LoadImageBitmap.GIF");
                }
            }

            if (ext == ".jpg" || ext == ".jpeg" || ext == ".jpe" || ext == ".jfif")
            {
                try
                {
                    using var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                    using var temp = new Bitmap(fs);

                    string format = _settings.BitmapFormat;

                    if (format == BitmapFormats.Rgb24)
                    {
                        if (temp.PixelFormat == GdiPixelFormat.Format24bppRgb)
                            return new Bitmap(temp);
                        return ConvertFormat(temp, GdiPixelFormat.Format24bppRgb);
                    }
                    else if (format == BitmapFormats.Argb32)
                    {
                        if (temp.PixelFormat == GdiPixelFormat.Format32bppArgb)
                            return new Bitmap(temp);
                        return ConvertFormat(temp, GdiPixelFormat.Format32bppArgb);
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.Write(ex, "LoadImageBitmap.GDI+");
                }
            }

            if (ext == ".svg")
            {
                return RenderSvgCached(filePath, _pictureBox.ClientSize.Width, _pictureBox.ClientSize.Height);
            }

            // RAW 相机格式
            if (IsRawExtension(ext))
            {
                using var magickImage = new MagickImage(filePath);
                return ApplyBitmapFormat(magickImage);
            }

            using var magickImage2 = new MagickImage(filePath);
            return ApplyBitmapFormat(magickImage2);
        }

        /// <summary>后台线程安全的纯解码：不访问任何 UI 控件。</summary>
        private Bitmap? DecodeForAsync(string filePath)
        {
            using var magickImage = new MagickImage(filePath);
            return ApplyBitmapFormat(magickImage);
        }

        /// <summary>预加载专用：后台线程安全，不访问 UI 控件。</summary>
        private Bitmap? LoadForPreload(string filePath)
        {
            string ext = Path.GetExtension(filePath).ToLowerInvariant();

            if (ext == ".gif" || ext == ".svg") return null;

            if (ext == ".jpg" || ext == ".jpeg" || ext == ".jpe" || ext == ".jfif")
            {
                try
                {
                    using var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                    using var temp = new Bitmap(fs);

                    string format = _settings.BitmapFormat;

                    if (format == BitmapFormats.Rgb24)
                    {
                        if (temp.PixelFormat == GdiPixelFormat.Format24bppRgb)
                            return new Bitmap(temp);
                        return ConvertFormat(temp, GdiPixelFormat.Format24bppRgb);
                    }
                    else if (format == BitmapFormats.Argb32)
                    {
                        if (temp.PixelFormat == GdiPixelFormat.Format32bppArgb)
                            return new Bitmap(temp);
                        return ConvertFormat(temp, GdiPixelFormat.Format32bppArgb);
                    }
                }
                catch
                {
                    return null;
                }
            }

            try
            {
                using var magickImage = new MagickImage(filePath);
                return ApplyBitmapFormat(magickImage);
            }
            catch
            {
                return null;
            }
        }

        /// <summary>后台预加载下一张图片到缓存。</summary>
        private void PreloadNext()
        {
            if (!_settings.EnablePreload) return;
            if (!_imageCache.IsEnabled) return;

            if (_imageFiles.Length <= 1) return;
            if (_currentIndex < 0) return;

            int nextIdx = (_currentIndex + 1) % _imageFiles.Length;
            if (nextIdx == _currentIndex) return;

            string nextPath = _imageFiles[nextIdx];
            string ext = Path.GetExtension(nextPath).ToLowerInvariant();

            if (ext == ".gif" || ext == ".svg") return;
            if (_imageCache.Contains(nextPath)) return;

            _preloadCts?.Cancel();
            var cts = new CancellationTokenSource();
            _preloadCts = cts;
            var token = cts.Token;

            Task.Run(() =>
            {
                if (token.IsCancellationRequested) return;

                Bitmap? bmp = null;
                try
                {
                    bmp = LoadForPreload(nextPath);
                }
                catch (Exception ex)
                {
                    LogHelper.Write(ex, "PreloadNext");
                }

                if (bmp == null) return;

                if (token.IsCancellationRequested)
                {
                    bmp.Dispose();
                    return;
                }

                _imageCache.Add(nextPath, bmp);
            });
        }

        /// <summary>加载 GIF 为多帧序列，返回第一帧。</summary>
        private Bitmap LoadGif(string filePath)
        {
            using var collection = new MagickImageCollection(filePath);

            if (collection.Count <= 1)
            {
                using var single = (MagickImage)collection[0];
                var bmp = ApplyBitmapFormat(single);
                return bmp;
            }

            collection.Coalesce();

            int count = Math.Min(collection.Count, GIF_MAX_FRAMES);

            var frames = new List<Bitmap>(count);
            var delays = new List<int>(count);

            for (int i = 0; i < count; i++)
            {
                var frame = (MagickImage)collection[i];

                var bmp = ApplyBitmapFormat(frame);
                frames.Add(bmp);

                int delayMs = (int)(frame.AnimationDelay * 10);
                if (delayMs < GIF_MIN_DELAY_MS)
                    delayMs = GIF_MIN_DELAY_MS;
                delays.Add(delayMs);
            }

            _gifFrames = frames;
            _gifDelays = delays;
            _gifFrameIndex = 0;

            return frames[0];
        }

        /// <summary>启动 GIF 动画计时器。</summary>
        private void StartGifAnimation()
        {
            if (_gifFrames == null || _gifFrames.Count <= 1) return;

            if (_gifTimer == null)
            {
                _gifTimer = new System.Windows.Forms.Timer();
                _gifTimer.Tick += GifTimer_Tick;
            }

            _gifFrameIndex = 0;
            _gifTimer.Interval = _gifDelays![0];
            _gifTimer.Start();
        }

        /// <summary>GIF 计时器回调。</summary>
        private void GifTimer_Tick(object? sender, EventArgs e)
        {
            if (_gifFrames == null || _gifFrames.Count == 0) return;

            _gifFrameIndex = (_gifFrameIndex + 1) % _gifFrames.Count;
            _originalBitmap = _gifFrames[_gifFrameIndex];

            if (_gifDelays != null && _gifFrameIndex < _gifDelays.Count)
            {
                _gifTimer!.Interval = _gifDelays[_gifFrameIndex];
            }

            _pictureBox.Invalidate();
        }

        /// <summary>停止并释放所有 GIF 帧。</summary>
        private void StopAndDisposeGif()
        {
            if (_gifTimer != null)
            {
                _gifTimer.Stop();
            }

            if (_gifFrames != null)
            {
                if (_originalBitmap != null && _gifFrames.Contains(_originalBitmap))
                {
                    _originalBitmap = null;
                }

                foreach (var bmp in _gifFrames)
                {
                    bmp.Dispose();
                }
                _gifFrames = null;
            }

            _gifDelays = null;
            _gifFrameIndex = 0;
        }

        /// <summary>显示当前索引对应的图片。</summary>
        private async void DisplayCurrentImage()
        {
            if (_currentIndex < 0 || _currentIndex >= _imageFiles.Length)
                return;

            var filePath = _imageFiles[_currentIndex];
            int myVersion = ++_loadVersion;

            _preloadCts?.Cancel();
            _preloadCts = null;

            StopAndDisposeGif();
            RestoreRotationState();

            if (_originalBitmap != null)
            {
                var oldBitmap = _originalBitmap;
                _originalBitmap = null;

                if (!_imageCache.ContainsBitmap(oldBitmap))
                {
                    oldBitmap.Dispose();
                }
            }

            _imageCache.ProtectedKey = null;
            _imageCache.ProtectedKey = filePath;

            string ext = Path.GetExtension(filePath).ToLowerInvariant();
            bool isGif = ext == ".gif";
            bool isSvg = ext == ".svg";

            Bitmap? cached = (isGif || isSvg) ? null : _imageCache.Get(filePath);

            if (cached != null)
            {
                DisplayCachedBitmap(filePath, cached);
                return;
            }

            long fileSize = 0;
            try { fileSize = new FileInfo(filePath).Length; } catch { }

            bool isLargePsd = (ext == ".psd" || ext == ".psb") &&
                               fileSize >= ASYNC_DECODE_THRESHOLD_BYTES;
            bool useAsync = _settings.EnableAsyncDecode && isLargePsd;

            if (useAsync)
            {
                await LoadAsyncAndDisplay(filePath, myVersion);
            }
            else
            {
                LoadSyncAndDisplay(filePath);
            }
        }

        /// <summary>缓存命中时的显示逻辑。</summary>
        private void DisplayCachedBitmap(string filePath, Bitmap cached)
        {
            _originalBitmap = cached;

            _isZoomed = false;
            _viewZoom = 1.0;
            _viewPanX = 0;
            _viewPanY = 0;
            _hasSelection = false;
            _isDrawing = false;
            _isPanning = false;
            _pictureBox.Cursor = Cursors.Default;

            Text = $"{AppConstants.AppName} - {Path.GetFileName(filePath)}";
            _statusLabel.Text = $"{_currentIndex + 1} / {_imageFiles.Length}  |  {Path.GetFileName(filePath)}";
            _statusDimensions.Text = $"{_originalBitmap.Width} x {_originalBitmap.Height}";
            _statusFormat.Text = Path.GetExtension(filePath).TrimStart('.').ToUpperInvariant();
            _statusSize.Text = FormatFileSize(new FileInfo(filePath).Length);
            _statusLoadTime.Text = "缓存";

            _exifButton.Visible = false;
            FitWindowToImage();
            PositionExifControls();

            _exifButton.Visible = _settings.ShowExifButton;
            if (_exifButton.Visible)
                _exifButton.BringToFront();

            if (_exifPanelVisible)
            {
                UpdateExifContent(filePath);
                _exifPanel.BringToFront();
            }

            _pictureBox.Invalidate();
            UpdateZoomLabel();

            PreloadNext();
        }

        /// <summary>同步加载并显示。</summary>
        private void LoadSyncAndDisplay(string filePath)
        {
            string ext = Path.GetExtension(filePath).ToLowerInvariant();
            bool isGif = ext == ".gif";
            bool isSvg = ext == ".svg";

            _statusLoadTime.Text = "加载中...";
            Application.DoEvents();

            var sw = Stopwatch.StartNew();

            Bitmap? newBitmap = null;
            string? errorMessage = null;

            try
            {
                newBitmap = LoadImageBitmap(filePath);
            }
            catch (Exception ex)
            {
                errorMessage = ex.Message;
                LogHelper.Write(ex, "LoadSyncAndDisplay");
            }

            sw.Stop();

            if (errorMessage != null || newBitmap == null)
            {
                ShowLoadError(filePath, errorMessage, sw.Elapsed.TotalSeconds);
                return;
            }

            FinalizeDisplay(filePath, newBitmap, isGif, isSvg, $"{sw.Elapsed.TotalSeconds:0.##} 秒");
        }

        /// <summary>异步加载并显示（仅用于超大 PSD/PSB）。</summary>
        private async Task LoadAsyncAndDisplay(string filePath, int myVersion)
        {
            _loadingStartTime = DateTime.Now;

            if (_loadingElapsedTimer == null)
            {
                _loadingElapsedTimer = new System.Windows.Forms.Timer { Interval = 200 };
                _loadingElapsedTimer.Tick += (s, e) =>
                {
                    if (_loadingStartTime == default) return;
                    double sec = (DateTime.Now - _loadingStartTime).TotalSeconds;
                    _statusLoadTime.Text = $"加载中... {sec:0.0} 秒";
                };
            }
            _statusLoadTime.Text = "加载中... 0.0 秒";
            _loadingElapsedTimer.Start();

            var sw = Stopwatch.StartNew();

            Bitmap? newBitmap = null;
            string? errorMessage = null;

            try
            {
                await Task.Run(() =>
                {
                    try
                    {
                        newBitmap = DecodeForAsync(filePath);
                    }
                    catch (Exception ex)
                    {
                        errorMessage = ex.Message;
                    }
                });
            }
            catch (Exception ex)
            {
                errorMessage = ex.Message;
            }

            sw.Stop();
            _loadingElapsedTimer.Stop();
            _loadingStartTime = default;

            if (myVersion != _loadVersion)
            {
                newBitmap?.Dispose();
                return;
            }

            if (errorMessage != null || newBitmap == null)
            {
                LogHelper.Write(
                    new Exception(errorMessage ?? "异步解码返回空位图"),
                    "LoadAsyncAndDisplay");
                ShowLoadError(filePath, errorMessage ?? "解码失败", sw.Elapsed.TotalSeconds);
                return;
            }

            FinalizeDisplay(filePath, newBitmap, false, false, $"{sw.Elapsed.TotalSeconds:0.##} 秒");
        }

        /// <summary>显示加载失败信息。</summary>
        private void ShowLoadError(string filePath, string? errorMessage, double elapsedSec)
        {
            _statusLabel.Text = $"无法显示：{Path.GetFileName(filePath)}";
            _statusDimensions.Text = "";
            _statusFormat.Text = "";
            _statusSize.Text = "";
            _statusZoom.Text = "";
            _statusLoadTime.Text = $"{elapsedSec:0.##} 秒";
            MessageBox.Show($"无法显示该图片：{errorMessage}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Warning);
        }

        /// <summary>加载成功后的统一 UI 收尾。</summary>
        private void FinalizeDisplay(string filePath, Bitmap newBitmap, bool isGif, bool isSvg, string loadTimeText)
        {
            _originalBitmap = newBitmap;

            if (!isGif && !isSvg)
            {
                _imageCache.Add(filePath, newBitmap);
            }

            _isZoomed = false;
            _viewZoom = 1.0;
            _viewPanX = 0;
            _viewPanY = 0;
            _hasSelection = false;
            _isDrawing = false;
            _isPanning = false;
            _pictureBox.Cursor = Cursors.Default;

            Text = $"{AppConstants.AppName} - {Path.GetFileName(filePath)}";
            _statusLabel.Text = $"{_currentIndex + 1} / {_imageFiles.Length}  |  {Path.GetFileName(filePath)}";
            _statusDimensions.Text = $"{_originalBitmap.Width} x {_originalBitmap.Height}";
            _statusFormat.Text = Path.GetExtension(filePath).TrimStart('.').ToUpperInvariant();
            _statusSize.Text = FormatFileSize(new FileInfo(filePath).Length);
            _statusLoadTime.Text = loadTimeText;

            _exifButton.Visible = false;
            FitWindowToImage();
            PositionExifControls();

            _exifButton.Visible = _settings.ShowExifButton;
            if (_exifButton.Visible)
                _exifButton.BringToFront();

            if (_exifPanelVisible)
            {
                UpdateExifContent(filePath);
                _exifPanel.BringToFront();
            }

            if (_gifFrames != null && _gifFrames.Count > 1)
            {
                StartGifAnimation();
            }

            _pictureBox.Invalidate();
            UpdateZoomLabel();

            PreloadNext();
        }

        /// <summary>SVG 渲染（带缓存）。</summary>
        private Bitmap RenderSvgCached(string filePath, int viewportW, int viewportH)
        {
            if (!_settings.EnableSvgCache || !_imageCache.IsEnabled)
                return RenderSvg(filePath, viewportW, viewportH);

            string key = $"{filePath}|{viewportW}x{viewportH}";

            var cached = _imageCache.Get(key);
            if (cached != null)
                return cached;

            var bmp = RenderSvg(filePath, viewportW, viewportH);
            _imageCache.Add(key, bmp);
            return bmp;
        }

        /// <summary>把 SVG 渲染成位图。</summary>
        private Bitmap RenderSvg(string filePath, int viewportW, int viewportH)
        {
            var svgDoc = SvgDocument.Open(filePath);

            double svgW = svgDoc.Width.Value;
            double svgH = svgDoc.Height.Value;
            if (svgW <= 0 || svgH <= 0) { svgW = 800; svgH = 800; }

            double aspect = svgH / svgW;

            int targetW, targetH;

            string mode = _settings.SvgRenderMode;
            if (mode == SvgRenderModes.Fixed)
            {
                targetW = Math.Max(16, _settings.SvgFixedWidth);
                targetH = (int)Math.Round(targetW * aspect);
            }
            else if (mode == SvgRenderModes.Original)
            {
                targetW = (int)Math.Round(svgW);
                targetH = (int)Math.Round(svgH);
            }
            else
            {
                int vw = viewportW;
                int vh = viewportH;
                if (vw <= 0) vw = 1200;
                if (vh <= 0) vh = 900;

                if (vw * aspect <= vh)
                {
                    targetW = vw;
                    targetH = (int)(vw * aspect);
                }
                else
                {
                    targetH = vh;
                    targetW = (int)(vh / aspect);
                }
            }

            int maxSize = Math.Max(256, _settings.SvgMaxSize);
            if (targetW > maxSize)
            {
                double scale = (double)maxSize / targetW;
                targetW = maxSize;
                targetH = (int)(targetH * scale);
            }
            if (targetH > maxSize)
            {
                double scale = (double)maxSize / targetH;
                targetH = maxSize;
                targetW = (int)(targetW * scale);
            }

            if (targetW < 1) targetW = 1;
            if (targetH < 1) targetH = 1;

            svgDoc.Width = targetW;
            svgDoc.Height = targetH;

            using var svgBmp = svgDoc.Draw();

            var result = new Bitmap(targetW, targetH, GdiPixelFormat.Format24bppRgb);
            using (var g = Graphics.FromImage(result))
            {
                string bg = _settings.SvgBackgroundColor;
                if (bg == SvgBackgroundColorValues.White)
                {
                    g.Clear(Color.White);
                }
                else if (bg == SvgBackgroundColorValues.Checkerboard)
                {
                    DrawCheckerboard(g, targetW, targetH);
                }
                else
                {
                    g.Clear(Color.Black);
                }

                g.DrawImage(svgBmp, 0, 0, targetW, targetH);
            }

            return result;
        }

        /// <summary>把 MagickImage 转成指定格式的 Bitmap。</summary>
        private Bitmap ApplyBitmapFormat(MagickImage magickImage)
        {
            string format = _settings.BitmapFormat;

            if (format == BitmapFormats.Gray8)
            {
                magickImage.ColorSpace = ColorSpace.Gray;
            }
            else if (format != BitmapFormats.Argb32 && magickImage.HasAlpha)
            {
                magickImage.Alpha(AlphaOption.Remove);
            }

            var source = magickImage.ToBitmap();

            switch (format)
            {
                case BitmapFormats.Argb32:
                    if (source.PixelFormat == GdiPixelFormat.Format32bppArgb)
                        return source;
                    return ConvertFormat(source, GdiPixelFormat.Format32bppArgb);

                case BitmapFormats.Rgb16:
                    if (source.PixelFormat == GdiPixelFormat.Format16bppRgb565)
                        return source;
                    return ConvertFormat(source, GdiPixelFormat.Format16bppRgb565);

                case BitmapFormats.Gray8:
                    var gray = To8bppGray(source);
                    source.Dispose();
                    return gray;

                case BitmapFormats.Rgb24:
                default:
                    if (source.PixelFormat == GdiPixelFormat.Format24bppRgb)
                        return source;
                    return ConvertFormat(source, GdiPixelFormat.Format24bppRgb);
            }
        }

        /// <summary>读取并显示 EXIF 信息面板内容。</summary>
        private void UpdateExifContent(string filePath)
        {
            var sb = new StringBuilder();

            try
            {
                using var magick = new MagickImage(filePath);

                sb.AppendLine("【图像信息】");
                sb.AppendLine($"  尺寸：{magick.Width} x {magick.Height}");
                sb.AppendLine($"  格式：{magick.Format}");
                sb.AppendLine();

                var profile = magick.GetExifProfile();
                if (profile == null)
                {
                    sb.AppendLine("该图片不含 EXIF 信息。");
                    _exifContent.Text = sb.ToString();
                    MeasureAndResizeExif();
                    return;
                }

                sb.AppendLine("【相机信息】");
                AppendExifLine(sb, profile, ExifTag.Make, "制造商");
                AppendExifLine(sb, profile, ExifTag.Model, "型号");
                AppendExifLine(sb, profile, ExifTag.LensModel, "镜头");
                sb.AppendLine();

                sb.AppendLine("【拍摄参数】");
                AppendExifLine(sb, profile, ExifTag.FNumber, "光圈");
                AppendExifLine(sb, profile, ExifTag.ExposureTime, "快门");
                AppendExifLine(sb, profile, ExifTag.ISOSpeedRatings, "ISO");
                AppendExifLine(sb, profile, ExifTag.FocalLength, "焦距");
                AppendExifLine(sb, profile, ExifTag.ExposureProgram, "曝光程序");
                AppendExifLine(sb, profile, ExifTag.Flash, "闪光灯");
                sb.AppendLine();

                sb.AppendLine("【时间信息】");
                AppendExifLine(sb, profile, ExifTag.DateTimeOriginal, "拍摄时间");
                AppendExifLine(sb, profile, ExifTag.DateTimeDigitized, "数字化时间");
                sb.AppendLine();

                sb.AppendLine("【GPS】");
                string? gpsLat = GetExifString(profile, ExifTag.GPSLatitude);
                string? gpsLon = GetExifString(profile, ExifTag.GPSLongitude);
                if (string.IsNullOrEmpty(gpsLat) && string.IsNullOrEmpty(gpsLon))
                {
                    sb.AppendLine("  无");
                }
                else
                {
                    sb.AppendLine($"  纬度：{gpsLat}");
                    sb.AppendLine($"  经度：{gpsLon}");
                }
            }
            catch (Exception ex)
            {
                sb.AppendLine($"读取 EXIF 失败：{ex.Message}");
                LogHelper.Write(ex, "UpdateExifContent");
            }

            _exifContent.Text = sb.ToString();
            MeasureAndResizeExif();
        }

        /// <summary>测量 EXIF 文本高度并调整面板尺寸。</summary>
        private void MeasureAndResizeExif()
        {
            int contentWidth = _exifPanel.ClientSize.Width - _exifContent.Padding.Horizontal - 20;
            if (contentWidth < 50) contentWidth = 50;

            var measured = TextRenderer.MeasureText(
                _exifContent.Text,
                _exifContent.Font,
                new Size(contentWidth, int.MaxValue),
                TextFormatFlags.WordBreak | TextFormatFlags.NoPadding);

            _exifContent.Height = measured.Height + _exifContent.Padding.Vertical + 20;
            PositionExifControls();
        }

        /// <summary>在 EXIF 文本里追加一行。</summary>
        private void AppendExifLine(StringBuilder sb, IExifProfile profile, ExifTag tag, string label)
        {
            string? val = GetExifString(profile, tag);
            if (!string.IsNullOrWhiteSpace(val))
            {
                sb.AppendLine($"  {label}：{val}");
            }
        }

        /// <summary>从 EXIF profile 取指定标签的字符串值。</summary>
        private string? GetExifString(IExifProfile profile, ExifTag tag)
        {
            try
            {
                foreach (var value in profile.Values)
                {
                    if (value.Tag == tag)
                    {
                        string s = value.ToString() ?? string.Empty;

                        if (s.StartsWith("["))
                        {
                            int idx = s.IndexOf(']');
                            if (idx >= 0) s = s.Substring(idx + 1).TrimStart();
                        }

                        return s;
                    }
                }
                return null;
            }
            catch
            {
                return null;
            }
        }
    }
}