solidworks 按partdox包围框改零件名字 c#

using SolidWorks.Interop.sldworks;
using SolidWorks.Interop.swconst;
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace SolidWorksAddinStudy
{
    internal static class NameSizeMatchService
    {
        internal readonly struct NameSizeMatchResult
        {
            public NameSizeMatchResult(int parsedCount, int mismatchCount, int replacedCount, int replaceFailCount)
            {
                ParsedCount = parsedCount;
                MismatchCount = mismatchCount;
                ReplacedCount = replacedCount;
                ReplaceFailCount = replaceFailCount;
            }

            public int ParsedCount { get; }
            public int MismatchCount { get; }
            public int ReplacedCount { get; }
            public int ReplaceFailCount { get; }
        }

        public static NameSizeMatchResult Run(ModelDoc2 rootAssemblyModel)
        {
            int parsedCount = 0;
            int mismatchCount = 0;
            int replacedCount = 0;
            int replaceFailCount = 0;
            var visitedAssemblies = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

            ProcessAssembly(
                rootAssemblyModel,
                ref parsedCount,
                ref mismatchCount,
                ref replacedCount,
                ref replaceFailCount,
                visitedAssemblies);

            return new NameSizeMatchResult(parsedCount, mismatchCount, replacedCount, replaceFailCount);
        }

        private static void ProcessAssembly(
            ModelDoc2 assemblyModel,
            ref int parsedCount,
            ref int mismatchCount,
            ref int replacedCount,
            ref int replaceFailCount,
            HashSet<string> visitedAssemblies)
        {
            if (assemblyModel == null || assemblyModel.GetType() != (int)swDocumentTypes_e.swDocASSEMBLY)
            {
                return;
            }

            string asmKey = assemblyModel.GetPathName();
            if (string.IsNullOrWhiteSpace(asmKey))
            {
                asmKey = assemblyModel.GetTitle();
            }

            if (!visitedAssemblies.Add(asmKey))
            {
                return;
            }

            AssemblyDoc swAssembly = (AssemblyDoc)assemblyModel;
            // 只获取当前层级组件，递归时再进入子装配体，避免重复全量遍历导致卡顿
            object[] components = (object[])swAssembly.GetComponents(true);
            if (components == null || components.Length == 0)
            {
                return;
            }

            const double tolerance = 0.5; // mm

            foreach (object compObj in components)
            {
                Component2 comp = (Component2)compObj;
                ModelDoc2 compModel = null;

                try
                {
                    compModel = (ModelDoc2)comp.GetModelDoc2();
                }
                catch
                {
                    compModel = null;
                }

                if (compModel != null && compModel.GetType() == (int)swDocumentTypes_e.swDocASSEMBLY)
                {
                    ProcessAssembly(
                        compModel,
                        ref parsedCount,
                        ref mismatchCount,
                        ref replacedCount,
                        ref replaceFailCount,
                        visitedAssemblies);
                    continue;
                }

                string originalComponentName = comp.Name2 ?? string.Empty;
                string rawName = NormalizeComponentName(originalComponentName);

                if (!TryParseSizeFromName(rawName, out double[] nameDims))
                {
                    continue;
                }

                parsedCount++;

                if (!TryGetComponentDimensionsMm(comp, out double[] boxDims))
                {
                    Console.WriteLine($"[跳过] {rawName} -> 无法获取GetBox尺寸");
                    continue;
                }

                if (AreDimensionsClose(nameDims, boxDims, tolerance))
                {
                    continue;
                }

                mismatchCount++;
                string targetSizeToken = FormatDims(boxDims);
                string updatedComponentName = ReplaceSizeTokenInName(originalComponentName, targetSizeToken);

                if (string.Equals(updatedComponentName, originalComponentName, StringComparison.Ordinal))
                {
                    replaceFailCount++;
                    Console.WriteLine($"[不匹配-未替换] {rawName} | 名称:{FormatDims(nameDims)} | GetBox:{targetSizeToken}");
                    continue;
                }

                bool renamed = TryRenameComponent(assemblyModel, comp, updatedComponentName, targetSizeToken, out string renameMessage);
                if (renamed)
                {
                    replacedCount++;
                    Console.WriteLine($"[已替换] {rawName} | 名称:{FormatDims(nameDims)} -> {targetSizeToken}");
                }
                else
                {
                    replaceFailCount++;
                    Console.WriteLine($"[不匹配-替换失败] {rawName} | 目标:{targetSizeToken} | 原因:{renameMessage}");
                }
            }
        }

        private static bool TryRenameComponent(ModelDoc2 assemblyModel, Component2 comp, string updatedComponentName, string targetSizeToken, out string message)
        {
            message = string.Empty;
            if (assemblyModel == null)
            {
                message = "装配体文档为空";
                return false;
            }

            string targetLeafName = ExtractLeafComponentName(updatedComponentName);
            if (string.IsNullOrWhiteSpace(targetLeafName))
            {
                message = "目标名称为空";
                return false;
            }

            // 使用官方 RenameDocument 时不手动拼实例后缀，由 SW 自动处理重名实例。
            string renameTarget = targetLeafName;
            if (TryStripInstanceSuffix(targetLeafName, out string strippedTargetName))
            {
                renameTarget = strippedTargetName;
            }

            if (string.IsNullOrWhiteSpace(renameTarget))
            {
                message = "目标名称为空";
                return false;
            }

            string finalName = comp.Name2 ?? string.Empty;
            try
            {
                bool selected = comp.Select4(false, null, false);
                if (!selected)
                {
                    message = "组件选择失败";
                    return false;
                }

                ModelDocExtension modelExt = assemblyModel.Extension;
                if (modelExt == null)
                {
                    message = "ModelDocExtension 为空";
                    return false;
                }

                int renameError = modelExt.RenameDocument(renameTarget);
                finalName = comp.Name2 ?? string.Empty;
                if (renameError == (int)swRenameDocumentError_e.swRenameDocumentError_None)
                {
                    return true;
                }

                message = $"RenameDocument失败: error={renameError}, 目标[{renameTarget}], 当前[{finalName}]";
                return false;
            }
            catch (Exception ex)
            {
                message = $"RenameDocument异常: {ex.Message}";
                return false;
            }
        }

        private static bool IsRenameApplied(string currentComponentName, string targetInstanceName, string targetSizeToken, double[] targetDims)
        {
            string currentLeafName = ExtractLeafComponentName(currentComponentName ?? string.Empty);
            if (string.Equals(currentLeafName, targetInstanceName, StringComparison.OrdinalIgnoreCase))
            {
                return true;
            }

            string normalizedCurrentName = NormalizeComponentName(currentLeafName);
            if (!string.IsNullOrWhiteSpace(normalizedCurrentName))
            {
                if (!string.IsNullOrWhiteSpace(targetSizeToken) &&
                    normalizedCurrentName.IndexOf(targetSizeToken, StringComparison.OrdinalIgnoreCase) >= 0)
                {
                    return true;
                }

                if (targetDims != null &&
                    targetDims.Length == 3 &&
                    TryParseSizeFromName(normalizedCurrentName, out double[] currentDims) &&
                    AreDimensionsClose(currentDims, targetDims, 0.001))
                {
                    return true;
                }
            }

            return false;
        }

        private static string NormalizeComponentName(string componentName)
        {
            if (string.IsNullOrWhiteSpace(componentName))
            {
                return string.Empty;
            }

            int slashIndex = componentName.LastIndexOf('/');
            if (slashIndex >= 0 && slashIndex < componentName.Length - 1)
            {
                componentName = componentName.Substring(slashIndex + 1);
            }

            int lastDashIndex = componentName.LastIndexOf('-');
            if (lastDashIndex > 0 && lastDashIndex < componentName.Length - 1)
            {
                string suffix = componentName.Substring(lastDashIndex + 1);
                if (int.TryParse(suffix, out _))
                {
                    componentName = componentName.Substring(0, lastDashIndex);
                }
            }

            return componentName;
        }

        private static string ExtractLeafComponentName(string componentName)
        {
            if (string.IsNullOrWhiteSpace(componentName))
            {
                return string.Empty;
            }

            int slashIndex = componentName.LastIndexOf('/');
            if (slashIndex >= 0 && slashIndex < componentName.Length - 1)
            {
                return componentName.Substring(slashIndex + 1);
            }

            return componentName;
        }

        private static bool TryGetInstanceSuffix(string componentName, out string suffix)
        {
            suffix = string.Empty;
            string leaf = ExtractLeafComponentName(componentName);
            int lastDashIndex = leaf.LastIndexOf('-');
            if (lastDashIndex > 0 && lastDashIndex < leaf.Length - 1)
            {
                string possibleSuffix = leaf.Substring(lastDashIndex + 1);
                if (int.TryParse(possibleSuffix, out _))
                {
                    suffix = possibleSuffix;
                    return true;
                }
            }

            return false;
        }

        private static bool HasInstanceSuffix(string componentName)
        {
            return TryGetInstanceSuffix(componentName, out _);
        }

        private static bool TryStripInstanceSuffix(string componentName, out string nameWithoutSuffix)
        {
            nameWithoutSuffix = string.Empty;
            string leaf = ExtractLeafComponentName(componentName);
            int lastDashIndex = leaf.LastIndexOf('-');
            if (lastDashIndex > 0 && lastDashIndex < leaf.Length - 1)
            {
                string possibleSuffix = leaf.Substring(lastDashIndex + 1);
                if (int.TryParse(possibleSuffix, out _))
                {
                    nameWithoutSuffix = leaf.Substring(0, lastDashIndex);
                    return true;
                }
            }

            return false;
        }

        private static bool TryParseSizeFromName(string name, out double[] dims)
        {
            dims = Array.Empty<double>();
            if (string.IsNullOrWhiteSpace(name))
            {
                return false;
            }

            var match = Regex.Match(name, @"(\d+(?:\.\d+)?)\s*[xX×]\s*(\d+(?:\.\d+)?)\s*[xX×]\s*(\d+(?:\.\d+)?)");
            if (!match.Success)
            {
                return false;
            }

            if (!double.TryParse(match.Groups[1].Value, out double d1) ||
                !double.TryParse(match.Groups[2].Value, out double d2) ||
                !double.TryParse(match.Groups[3].Value, out double d3))
            {
                return false;
            }

            dims = new[] { d1, d2, d3 };
            Array.Sort(dims);
            return true;
        }

        private static bool TryGetComponentDimensionsMm(Component2 comp, out double[] dims)
        {
            dims = Array.Empty<double>();
            object boxObj = comp.GetBox(false, false);
            if (boxObj == null || !(boxObj is double[]))
            {
                return false;
            }

            double[] box = (double[])boxObj;
            if (box.Length < 6)
            {
                return false;
            }

            double length = Math.Abs(box[3] - box[0]) * 1000.0;
            double width = Math.Abs(box[4] - box[1]) * 1000.0;
            double height = Math.Abs(box[5] - box[2]) * 1000.0;

            dims = new[] { length, width, height };
            Array.Sort(dims);
            return true;
        }

        private static bool AreDimensionsClose(double[] a, double[] b, double tolerance)
        {
            if (a == null || b == null || a.Length != 3 || b.Length != 3)
            {
                return false;
            }

            return Math.Abs(a[0] - b[0]) <= tolerance &&
                   Math.Abs(a[1] - b[1]) <= tolerance &&
                   Math.Abs(a[2] - b[2]) <= tolerance;
        }

        private static string FormatDims(double[] dims)
        {
            if (dims == null || dims.Length != 3)
            {
                return "-";
            }

            return $"{dims[0]:0.###}x{dims[1]:0.###}x{dims[2]:0.###}";
        }

        private static string ReplaceSizeTokenInName(string name, string replacementSizeToken)
        {
            if (string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(replacementSizeToken))
            {
                return name;
            }

            const string sizePattern = @"(\d+(?:\.\d+)?)\s*[xX×]\s*(\d+(?:\.\d+)?)\s*[xX×]\s*(\d+(?:\.\d+)?)";
            var regex = new Regex(sizePattern);
            return regex.Replace(name, replacementSizeToken, 1);
        }
    }
}