求助，万能的网友
以下是一段沿路径阵列的代码，程序总是出错，我的需求是：
1.修正代码（平台为AutoCAD 2014）
2.添加一个界面窗口，类似于3dmax中的间隔工具。


  1. using Autodesk.AutoCAD.ApplicationServices;
  2. using Autodesk.AutoCAD.DatabaseServices;
  3. using Autodesk.AutoCAD.EditorInput;
  4. using Autodesk.AutoCAD.Geometry;
  5. using Autodesk.AutoCAD.Runtime;
  6. using System;

  8. namespace AutoCADCommands
  9. {
  10.     public class PathArrayCommand
  11.     {
  12.         // 1. 定义常驻程序的阵列参数变量
  13.         private static string arrayMethod = "Measure";        // 阵列方法，默认为测量方式
  14.         private static double arraySpacing = 5.0;            // 阵列间距，默认为5.0
  15.         private static int arrayCount = 5;                   // 阵列数量，默认为5
  16.         private static double pathStartOffset = 0.0;         // 始端偏移距离，默认为0.0
  17.         private static double pathEndOffset = 0.0;           // 末端偏移距离，默认为0.0
  18.         private static bool rotateWithPath = true;           // 是否旋转至切线方向，默认为true

  20.         [CommandMethod("PATHARRAY")]
  21.         public static void PathArray()
  22.         {
  23.             var doc = Application.DocumentManager.MdiActiveDocument;
  24.             var db = doc.Database;
  25.             var ed = doc.Editor;

  27.             try
  28.             {
  29.                 // 2. 选择要阵列的对象
  30.                 PromptSelectionOptions selOptions = new PromptSelectionOptions();
  31.                 selOptions.MessageForAdding = "\n选择要阵列的对象: ";
  32.                 PromptSelectionResult selectionResult = ed.GetSelection(selOptions);
  33.                 if (selectionResult.Status != PromptStatus.OK)
  34.                 {
  35.                     ed.WriteMessage("\n未选择对象，命令取消。");
  36.                     return; // 未选择对象，退出程序
  37.                 }

  39.                 // 计算选择对象的中心点（只考虑二维平面）
  40.                 Point3d selectionCenter = Point3d.Origin;
  41.                 bool hasValidEntity = false;
  42.                 double minX = 0, minY = 0, maxX = 0, maxY = 0;

  44.                 using (Transaction tr = db.TransactionManager.StartTransaction())
  45.                 {
  46.                     try
  47.                     {
  48.                         ObjectId[] objectIds = selectionResult.Value.GetObjectIds();
  49.                         
  50.                         // 遍历所有选中的对象，计算二维边界框
  51.                         for (int i = 0; i < objectIds.Length; i++)
  52.                         {
  53.                             try
  54.                             {
  55.                                 Entity entity = tr.GetObject(objectIds, OpenMode.ForRead) as Entity;
  56.                                 if (entity != null && entity.Bounds.HasValue)
  57.                                 {
  58.                                     Extents3d extents = entity.Bounds.Value;
  59.                                     
  60.                                     // 只考虑二维坐标
  61.                                     double entityMinX = extents.MinPoint.X;
  62.                                     double entityMinY = extents.MinPoint.Y;
  63.                                     double entityMaxX = extents.MaxPoint.X;
  64.                                     double entityMaxY = extents.MaxPoint.Y;
  65.                                     
  66.                                     if (!hasValidEntity)
  67.                                     {
  68.                                         // 第一个有效对象，初始化边界值
  69.                                         minX = entityMinX;
  70.                                         minY = entityMinY;
  71.                                         maxX = entityMaxX;
  72.                                         maxY = entityMaxY;
  73.                                         hasValidEntity = true;
  74.                                     }
  75.                                     else
  76.                                     {
  77.                                         // 更新最小值和最大值
  78.                                         if (entityMinX < minX) minX = entityMinX;
  79.                                         if (entityMinY < minY) minY = entityMinY;
  80.                                         if (entityMaxX > maxX) maxX = entityMaxX;
  81.                                         if (entityMaxY > maxY) maxY = entityMaxY;
  82.                                     }
  83.                                 }
  84.                             }
  85.                             catch
  86.                             {
  87.                                 // 忽略无法处理的实体
  88.                                 continue;
  89.                             }
  90.                         }
  91.                     }
  92.                     catch (Autodesk.AutoCAD.Runtime.Exception ex)
  93.                     {
  94.                         ed.WriteMessage("\n计算中心点时出错:" + ex.Message);
  95.                         selectionCenter = new Point3d(0, 0, 0);
  96.                     }
  97.                     tr.Commit();
  98.                 }

  100.                 if (hasValidEntity)
  101.                 {
  102.                     // 计算二维几何中心点，Z坐标为0
  103.                     double centerX = (minX + maxX) / 2.0;
  104.                     double centerY = (minY + maxY) / 2.0;
  105.                     selectionCenter = new Point3d(centerX, centerY, 0.0);
  106.                 }
  107.                 else
  108.                 {
  109.                     ed.WriteMessage("\n未找到有效对象或对象没有边界框。");
  110.                     return;
  111.                 }

  113.                 // 3. 指定阵列基点<中心点>
  114.                 PromptPointOptions basePointOptions = new PromptPointOptions("\n指定阵列基点，或<中心点(Enter)>: ");
  115.                 basePointOptions.AllowNone = true;
  116.                 basePointOptions.UseBasePoint = true;
  117.                 basePointOptions.BasePoint = selectionCenter;

  119.                 PromptPointResult basePointResult = ed.GetPoint(basePointOptions);
  120.                 Point3d basePoint;
  121.                 if (basePointResult.Status == PromptStatus.Cancel)
  122.                 {
  123.                     ed.WriteMessage("\n命令已取消。");
  124.                     return;
  125.                 }
  126.                 else if (basePointResult.Status == PromptStatus.None)
  127.                 {
  128.                     // 用户按了Enter，使用计算出的中心点
  129.                     basePoint = selectionCenter;
  130.                 }
  131.                 else if (basePointResult.Status == PromptStatus.OK)
  132.                 {
  133.                     // 用户指定了点，使用该点
  134.                     basePoint = basePointResult.Value;
  135.                     // 确保Z坐标为0（二维平面）
  136.                     basePoint = new Point3d(basePoint.X, basePoint.Y, 0.0);
  137.                 }
  138.                 else
  139.                 {
  140.                     // 其他状态，使用默认中心点
  141.                     basePoint = selectionCenter;
  142.                 }

  144.                 // 4. 显示当前阵列参数并提示用户修改
  145.                 bool continueEditingParams = true;
  146.                 while (continueEditingParams)
  147.                 {
  148.                     try
  149.                     {
  150.                         // 显示当前参数
  151.                         string offsetInfo = "始端偏移<" + pathStartOffset.ToString("F2") + ">，末端偏移<" + pathEndOffset.ToString("F2") + ">，旋转< " + (rotateWithPath ? "是" : "否") + ">";
  152.                         if (arrayMethod == "Measure")
  153.                         {
  154.                             ed.WriteMessage("\n当前阵列参数:按间距<" + arraySpacing.ToString("F2") + ">，" + offsetInfo);
  155.                         }
  156.                         else
  157.                         {
  158.                             ed.WriteMessage("\n当前阵列参数:按数量<" + arrayCount.ToString() + ">，" + offsetInfo);
  159.                         }

  161.                         // 提示用户选择参数选项
  162.                         PromptKeywordOptions paramOptions = new PromptKeywordOptions("\n选择阵列参数[间距(Distance)/数量(Count)/始端偏移(Start)/末端偏移(End)/旋转(Rotate)]<确定(Enter)>: ");
  163.                         paramOptions.Keywords.Add("Distance");
  164.                         paramOptions.Keywords.Add("Count");
  165.                         paramOptions.Keywords.Add("Start");
  166.                         paramOptions.Keywords.Add("End");
  167.                         paramOptions.Keywords.Add("Rotate");
  168.                         paramOptions.AllowNone = true;  //按 ENTER 键（NULL 输入）时使用默认值
  169.                         paramOptions.Keywords.Default = "None";

  171.                         PromptResult paramResult = ed.GetKeywords(paramOptions);

  173.                         if (paramResult.Status == PromptStatus.OK)
  174.                         {
  175.                             switch (paramResult.StringResult)
  176.                             {
  177.                                 case "Distance": // 设置间距
  178.                                     PromptDistanceOptions spacingOptions = new PromptDistanceOptions("\n指定间距 <" + arraySpacing.ToString("F2") + ">: ");
  179.                                     spacingOptions.DefaultValue = arraySpacing;
  180.                                     spacingOptions.AllowNegative = false;
  181.                                     spacingOptions.AllowZero = false;
  182.                                     spacingOptions.UseBasePoint = true;
  183.                                     spacingOptions.BasePoint = basePoint;

  185.                                     PromptDoubleResult spacingResult = ed.GetDistance(spacingOptions);
  186.                                     if (spacingResult.Status == PromptStatus.OK)
  187.                                     {
  188.                                         arraySpacing = spacingResult.Value;
  189.                                         arrayMethod = "Measure"; // 切换到测量方式
  190.                                     }
  191.                                     break;

  193.                                 case "Count": // 设置数量
  194.                                     PromptIntegerOptions countOptions = new PromptIntegerOptions("\n输入数量 <" + arrayCount + ">: ");
  195.                                     countOptions.DefaultValue = arrayCount;
  196.                                     countOptions.LowerLimit = 2;

  198.                                     PromptIntegerResult countResult = ed.GetInteger(countOptions);
  199.                                     if (countResult.Status == PromptStatus.OK)
  200.                                     {
  201.                                         arrayCount = countResult.Value;
  202.                                         arrayMethod = "Count"; // 切换到等分方式
  203.                                     }
  204.                                     break;

  206.                                 case "Start": // 设置始端偏移
  207.                                     PromptDistanceOptions startOffsetOptions = new PromptDistanceOptions("\n指定始端偏移距离 <" + pathStartOffset.ToString("F2") + ">: ");
  208.                                     startOffsetOptions.DefaultValue = pathStartOffset;
  209.                                     startOffsetOptions.AllowNegative = false; // 不允许负值，只能从起点向后偏移

  211.                                     PromptDoubleResult startOffsetResult = ed.GetDistance(startOffsetOptions);
  212.                                     if (startOffsetResult.Status == PromptStatus.OK)
  213.                                     {
  214.                                         pathStartOffset = startOffsetResult.Value;
  215.                                     }
  216.                                     break;

  218.                                 case "End": // 设置末端偏移
  219.                                     PromptDistanceOptions endOffsetOptions = new PromptDistanceOptions("\n指定末端偏移距离 <" + pathEndOffset.ToString("F2") + ">: ");
  220.                                     endOffsetOptions.DefaultValue = pathEndOffset;
  221.                                     endOffsetOptions.AllowNegative = false; // 不允许负值，只能从终点向前偏移

  223.                                     PromptDoubleResult endOffsetResult = ed.GetDistance(endOffsetOptions);
  224.                                     if (endOffsetResult.Status == PromptStatus.OK)
  225.                                     {
  226.                                         pathEndOffset = endOffsetResult.Value;
  227.                                     }
  228.                                     break;

  230.                                 case "Rotate": // 切换旋转选项
  231.                                     rotateWithPath = !rotateWithPath;
  232.                                     ed.WriteMessage("\n路径旋转已" + (rotateWithPath ? "开启" : "关闭"));
  233.                                     break;
  234.                             }
  235.                         }
  236.                         else if (paramResult.Status == PromptStatus.None)
  237.                         {
  238.                             continueEditingParams = false; // 用户按回车，结束参数设置
  239.                         }
  240.                         else
  241.                         {
  242.                             ed.WriteMessage("\n用户取消，退出程序。");
  243.                             return;
  244.                         }
  245.                     }
  246.                     catch (Autodesk.AutoCAD.Runtime.Exception ex)
  247.                     {
  248.                         ed.WriteMessage("\n参数设置时出错:" + ex.Message);
  249.                         continueEditingParams = false;
  250.                     }
  251.                 }

  253.                 // 5. 开始路径阵列循环
  254.                 bool continueArray = true;
  255.                 while (continueArray)
  256.                 {
  257.                     try
  258.                     {
  259.                         // 点选一条路径
  260.                         PromptEntityOptions pathOptions = new PromptEntityOptions("\n选择路径: ");
  261.                         pathOptions.SetRejectMessage("\n所选对象不是有效路径。");
  262.                         pathOptions.AddAllowedClass(typeof(Curve), false);

  264.                         PromptEntityResult pathResult = ed.GetEntity(pathOptions);
  265.                         if (pathResult.Status == PromptStatus.Cancel)
  266.                         {
  267.                             ed.WriteMessage("\n命令取消。");
  268.                             break;
  269.                         }
  270.                         else if (pathResult.Status != PromptStatus.OK)
  271.                         {
  272.                             break; // 未选择路径，结束循环
  273.                         }

  275.                         // 检查是否为有效路径（排除构造线和射线）
  276.                         using (Transaction tr = db.TransactionManager.StartOpenCloseTransaction())
  277.                         {
  278.                             DBObject obj = tr.GetObject(pathResult.ObjectId, OpenMode.ForRead);
  279.                             string dxfName = obj.GetType().Name;
  280.                             if (dxfName == "Xline" || dxfName == "Ray")
  281.                             {
  282.                                 ed.WriteMessage("\n构造线和射线不能作为路径。");
  283.                                 continue;
  284.                             }
  285.                         }

  287.                         // 沿该路径创建对象阵列
  288.                         if (!CreatePathArray(db, ed, basePoint, selectionResult.Value.GetObjectIds(),pathResult.ObjectId))
  289.                         {
  290.                             ed.WriteMessage("\n阵列创建失败。");
  291.                         }

  293.                         // 询问是否继续
  294.                         PromptKeywordOptions continueOptions = new PromptKeywordOptions("\n是否继续阵列? [是(Y)/否(N)] <是>: ");
  295.                         continueOptions.Keywords.Add("Y");
  296.                         continueOptions.Keywords.Add("N");
  297.                         continueOptions.AllowNone = true;
  298.                         continueOptions.Keywords.Default = "Y";

  300.                         PromptResult continueResult = ed.GetKeywords(continueOptions);
  301.                         if (continueResult.Status == PromptStatus.Cancel)
  302.                         {
  303.                             ed.WriteMessage("\n命令取消。");
  304.                             continueArray = false;
  305.                         }
  306.                         else if (continueResult.Status != PromptStatus.OK ||
  307.                                 (continueResult.StringResult == "N" ||
  308.                                 (continueResult.Status == PromptStatus.None && continueResult.StringResult != "Y")))
  309.                         {
  310.                             continueArray = false;
  311.                         }
  312.                     }
  313.                     catch (Autodesk.AutoCAD.Runtime.Exception ex)
  314.                     {
  315.                         ed.WriteMessage("\n阵列过程中出错: " +ex.Message);
  316.                         continueArray = false;
  317.                     }
  318.                 }

  320.                 ed.WriteMessage("\n路径阵列完成。");
  321.             }
  322.             catch (System.Runtime.InteropServices.SEHException sehEx)
  323.             {
  324.                 ed.WriteMessage("\n系统异常: 请确保选择的对象类型正确。");
  325.                 Application.DocumentManager.MdiActiveDocument.SendStringToExecute("(princ)\n", true, false, false);
  326.             }
  327.             catch (Autodesk.AutoCAD.Runtime.Exception ex)
  328.             {
  329.                 ed.WriteMessage("\n命令执行时发生错误: " +ex.Message);
  330.                 Application.DocumentManager.MdiActiveDocument.SendStringToExecute("(princ)\n", true, false, false);
  331.             }
  332.         }

  334.         // 创建路径阵列的辅助方法（二维平面）
  335.         private static bool CreatePathArray(Database db, Editor ed, Point3d basePoint,
  336.                                            ObjectId[] sourceIds, ObjectId pathId)
  337.         {
  338.             using (Transaction tr = db.TransactionManager.StartTransaction())
  339.             {
  340.                 try
  341.                 {
  342.                     // 获取路径曲线
  343.                     Curve path = tr.GetObject(pathId, OpenMode.ForRead) as Curve;
  344.                     if (path == null)
  345.                     {
  346.                         ed.WriteMessage("\n无法获取路径对象。");
  347.                         return false;
  348.                     }

  350.                     // 获取路径长度（二维平面）
  351.                     double totalLength = 0;
  352.                     try
  353.                     {
  354.                         totalLength = path.GetDistanceAtParameter(path.EndParam);
  355.                     }
  356.                     catch
  357.                     {
  358.                         // 对于某些类型的曲线，使用替代方法
  359.                         try
  360.                         {
  361.                             //totalLength = path.GetDistanceAtPoint(path.EndPoint);
  362.                             totalLength = path.GetDistAtPoint(path.EndPoint);
  363.                         }
  364.                         catch
  365.                         {
  366.                             ed.WriteMessage("\n无法计算路径长度。");
  367.                             return false;
  368.                         }
  369.                     }

  371.                     // 应用始端和末端偏移
  372.                     double effectiveLength = totalLength - pathStartOffset - pathEndOffset;
  373.                     if (effectiveLength <= 0)
  374.                     {
  375.                         ed.WriteMessage("\n路径长度不足或偏移量过大。");
  376.                         return false;
  377.                     }

  379.                     // 根据阵列方法计算元素位置
  380.                     double[] positions;
  381.                     if (arrayMethod == "Count") // 等分方式
  382.                     {
  383.                         if (arrayCount < 2)
  384.                         {
  385.                             ed.WriteMessage("\n阵列数量必须大于1。");
  386.                             return false;
  387.                         }

  389.                         positions = new double[arrayCount];
  390.                         double interval = effectiveLength / (arrayCount - 1);
  391.                         for (int i = 0; i < arrayCount; i++)
  392.                         {
  393.                             positions = pathStartOffset + i * interval;
  394.                         }
  395.                     }
  396.                     else // 测量方式
  397.                     {
  398.                         if (arraySpacing <= 0)
  399.                         {
  400.                             ed.WriteMessage("\n阵列间距必须大于0。");
  401.                             return false;
  402.                         }

  404.                         int count = (int)(effectiveLength / arraySpacing) + 1;
  405.                         if (count < 2) count = 2;

  407.                         positions = new double[count];
  408.                         for (int i = 0; i < count; i++)
  409.                         {
  410.                             positions = pathStartOffset + i * arraySpacing;
  411.                         }
  412.                     }

  414.                     // 获取路径起点处的切线方向（用于旋转参考）
  415.                     double startRotation = 0;
  416.                     if (rotateWithPath)
  417.                     {
  418.                         try
  419.                         {
  420.                             double startParam = path.GetParameterAtDistance(pathStartOffset);
  421.                             Vector3d startTangent = path.GetFirstDerivative(startParam).GetNormal();
  422.                            
  423.                             // 二维平面旋转，只考虑XY平面
  424.                             startRotation = Math.Atan2(startTangent.Y, startTangent.X);
  425.                         }
  426.                         catch
  427.                         {
  428.                             // 如果无法获取切线方向，使用默认值
  429.                             startRotation = 0;
  430.                         }
  431.                     }

  433.                     // 创建源对象的ID集合
  434.                     ObjectIdCollection sourceIdCollection = new ObjectIdCollection(sourceIds);

  436.                     // 沿路径创建每个阵列副本
  437.                     for (int i = 0; i < positions.Length; i++)
  438.                     {
  439.                         double distance = positions;

  441.                         // 确保距离在路径范围内
  442.                         if (distance < 0 || distance > totalLength)
  443.                             continue;

  445.                         // 获取路径上的点
  446.                         Point3d pointOnPath;
  447.                         try
  448.                         {
  449.                             pointOnPath = path.GetPointAtDist(distance);
  450.                             // 确保点在二维平面
  451.                             pointOnPath = new Point3d(pointOnPath.X, pointOnPath.Y, 0.0);
  452.                         }
  453.                         catch
  454.                         {
  455.                             // 如果距离超出范围，跳过
  456.                             continue;
  457.                         }

  459.                         // 克隆源对象
  460.                         IdMapping mapping = new IdMapping();
  461.                         db.DeepCloneObjects(sourceIdCollection, db.CurrentSpaceId, mapping, false);

  463.                         // 对克隆的对象应用变换
  464.                         foreach (IdPair pair in mapping)
  465.                         {
  466.                             if (pair.IsCloned && pair.IsPrimary)
  467.                             {
  468.                                 Entity clonedEntity = tr.GetObject(pair.Value, OpenMode.ForWrite) as Entity;
  469.                                 if (clonedEntity != null)
  470.                                 {
  471.                                     // 1. 从基点平移到路径点（二维平移）
  472.                                     Vector3d translation = basePoint.GetVectorTo(pointOnPath);
  473.                                     Matrix3d transform = Matrix3d.Displacement(translation);

  475.                                     // 2. 如果需要，旋转至切线方向（二维旋转）
  476.                                     if (rotateWithPath)
  477.                                     {
  478.                                         try
  479.                                         {
  480.                                             double currentParam = path.GetParameterAtDistance(distance);
  481.                                             Vector3d currentTangent = path.GetFirstDerivative(currentParam).GetNormal();
  482.                                             
  483.                                             // 二维平面旋转角度
  484.                                             double currentRotation = Math.Atan2(currentTangent.Y, currentTangent.X);
  485.                                             double rotationAngle = currentRotation - startRotation;

  487.                                             // 以路径点为中心旋转（Z轴旋转）
  488.                                             if (Math.Abs(rotationAngle) > 1e-10) // 避免微小旋转
  489.                                             {
  490.                                                 transform = transform *
  491.                                                     Matrix3d.Rotation(rotationAngle, Vector3d.ZAxis, pointOnPath);
  492.                                             }
  493.                                         }
  494.                                         catch
  495.                                         {
  496.                                             // 如果无法计算旋转，继续执行平移
  497.                                         }
  498.                                     }

  500.                                     // 应用变换
  501.                                     clonedEntity.TransformBy(transform);
  502.                                 }
  503.                             }
  504.                         }
  505.                     }

  507.                     tr.Commit();
  508.                     return true;
  509.                 }
  510.                 catch (System.Runtime.InteropServices.SEHException sehEx)
  511.                 {
  512.                     ed.WriteMessage("\n系统异常: 路径操作失败。");
  513.                     return false;
  514.                 }
  515.                 catch (Autodesk.AutoCAD.Runtime.Exception ex)
  516.                 {
  517.                     ed.WriteMessage("\n创建阵列时出错:"+  ex.Message);
  518.                     return false;
  519.                 }
  520.             }
  521.         }
  522.     }
  523. }




网友答: 我先来，AI生成的就让AI去完善

网友答:
tranque 发表于 2026-1-4 12:23
我先来，AI生成的就让AI去完善

人家都没有说时ai生产的啊


网友答:
qifeifei 发表于 2026-1-4 14:09
人家都没有说时ai生产的啊

感觉就很像

网友答: 代码质量越来越差了,连tr.GetObject(id)都不放using了...
而且开了n个事务,还混开了 StartOpenCloseTransaction...
不知道怎么评价

网友答: 楼主 这个代码怎么加载到CAD里  没接触过  求教

网友答: 本帖最后由 你有种再说一遍 于 2026-1-4 17:59 编辑
小鸟 发表于 2026-1-4 17:55
楼主 这个代码怎么加载到CAD里  没接触过  求教

去b站搜cad c#二次开发,需要下载vs(不是vs code),编译为dll.
  • 上一篇：图面工具箱径向菜单
  • 下一篇：没有了
    CAD技术交流中心 | 建筑CAD | 给排水CAD | 暖通CAD | 电气CAD | 电力CAD | 机械CAD | CAD母线槽 | CAD看图
    Copyright © 2019 - 2025