本帖最后由 wang2006zhi 于 2025-11-5 14:40 编辑
  2. <div class="blockcode"><blockquote>/// <summary>
  3. /// 简化版链式关联管理器
  4. /// </summary>
  5. public static class AssociationManager
  6. {
  7.     #region 内部结构
  8.    
  9.     /// <summary>
  10.     /// 关联信息
  11.     /// </summary>
  12.     private class AssociationAction
  13.     {
  14.         public Action? Action { get; set; }
  15.         public string Tag { get; set; } = "";
  16.     }

  18.     // 关联存储：源对象ID -> 关联信息列表
  19.     private static readonly Dictionary<ObjectId, List<AssociationAction>> Associations = new();
  20.    
  21.     // 防止递归更新的标记集合
  22.     private static readonly HashSet<ObjectId> UpdatingObjects = new();
  23.    
  24.     // 初始化标志
  25.     private static bool _isInitialized;

  27.     #endregion

  29.     #region 公共API

  31.     /// <summary>
  32.     /// 创建对象关联
  33.     /// </summary>
  34.     /// <param name="sourceId">源对象ID</param>
  35.     /// <param name="action">无参数关联动作</param>
  36.     /// <param name="tag">关联标签</param>
  37.     public static void AssocObjects(ObjectId sourceId, Action? action, string tag = "")
  38.     {
  39.         EnsureInitialized();
  40.         
  41.         if (sourceId.IsNull || action == null)
  42.             return;

  44.         // 获取或创建关联列表
  45.         if (!Associations.ContainsKey(sourceId))
  46.             Associations[sourceId] = new List<AssociationAction>();

  48.         // 检查是否已存在相同标签的关联
  49.         var existing = Associations[sourceId].FirstOrDefault(a => a.Tag == tag);
  50.         if (existing != null)
  51.             existing.Action = action; // 更新现有关联
  52.         else // 添加新关联
  53.             Associations[sourceId].Add(new AssociationAction
  54.             {
  55.                 Action = action,
  56.                 Tag = tag
  57.             });
  58.     }

  60.     /// <summary>
  61.     /// 移除对象的所有关联
  62.     /// </summary>
  63.     public static void RemoveAssociations(ObjectId sourceId)
  64.     {
  65.         Associations.Remove(sourceId);
  66.     }

  68.     /// <summary>
  69.     /// 移除特定标签的关联
  70.     /// </summary>
  71.     public static void RemoveAssociation(ObjectId sourceId, string tag)
  72.     {
  73.         if (!Associations.TryGetValue(sourceId, out var association)) return;
  74.         
  75.         association.RemoveAll(a => a.Tag == tag);
  76.         if (Associations[sourceId].Count == 0)
  77.             Associations.Remove(sourceId);
  78.     }

  80.     /// <summary>
  81.     /// 手动触发关联更新
  82.     /// </summary>
  83.     /// <param name="sourceId">源对象ID</param>
  84.     public static void UpdateAssociations(ObjectId sourceId)
  85.     {
  86.         if (!Associations.ContainsKey(sourceId) || UpdatingObjects.Contains(sourceId))
  87.             return;

  89.         ExecuteAssociations(sourceId);
  90.     }

  92.     /// <summary>
  93.     /// 检查是否存在关联
  94.     /// </summary>
  95.     public static bool HasAssociations(ObjectId sourceId)
  96.     {
  97.         return Associations.ContainsKey(sourceId);
  98.     }

  100.     /// <summary>
  101.     /// 获取关联统计信息
  102.     /// </summary>
  103.     public static string GetStats()
  104.     {
  105.         var sourceCount = Associations.Count;
  106.         var totalAssociations = Associations.Values.Sum(list => list.Count);
  107.         return $"关联源对象: {sourceCount}, 总关联数: {totalAssociations}";
  108.     }

  110.     #endregion

  112.     #region 核心实现

  114.     /// <summary>
  115.     /// 确保管理器已初始化
  116.     /// </summary>
  117.     private static void EnsureInitialized()
  118.     {
  119.         if (_isInitialized) return;
  120.         
  121.         var doc = Acaop.DocumentManager.MdiActiveDocument;
  122.         if (doc == null) return;
  123.         // 移除旧的事件处理（防止重复注册）
  124.         doc.Database.ObjectModified -= OnObjectModified;
  125.         doc.Database.ObjectErased -= OnObjectErased;
  126.             
  127.         // 注册新的事件处理
  128.         doc.Database.ObjectModified += OnObjectModified;
  129.         doc.Database.ObjectErased += OnObjectErased;
  130.         _isInitialized = true;
  131.     }

  133.     /// <summary>
  134.     /// 执行关联动作
  135.     /// </summary>
  136.     private static void ExecuteAssociations(ObjectId sourceId)
  137.     {
  138.         if (!Associations.ContainsKey(sourceId) || UpdatingObjects.Contains(sourceId))
  139.             return;

  141.         try
  142.         {
  143.             UpdatingObjects.Add(sourceId);
  144.             
  145.             foreach (var actionInfo in Associations[sourceId].ToList())
  146.             {
  147.                 try
  148.                 {
  149.                     // 执行关联动作
  150.                     actionInfo.Action?.Invoke();
  151.                 }
  152.                 catch (Exception ex)
  153.                 {
  154.                     Debug.WriteLine($"关联执行失败 [{actionInfo.Tag}]: {ex.Message}");
  155.                 }
  156.             }
  157.         }
  158.         finally
  159.         {
  160.             UpdatingObjects.Remove(sourceId);
  161.         }
  162.     }

  164.     /// <summary>
  165.     /// 对象修改事件处理
  166.     /// </summary>
  167.     private static void OnObjectModified(object sender, ObjectEventArgs e)
  168.     {
  169.         if (!Associations.ContainsKey(e.DBObject.Id) ||
  170.             UpdatingObjects.Contains(e.DBObject.Id))
  171.             return;

  173.         ExecuteAssociations(e.DBObject.Id);
  174.     }

  176.     /// <summary>
  177.     /// 对象删除事件处理
  178.     /// </summary>
  179.     private static void OnObjectErased(object sender, ObjectErasedEventArgs e)
  180.     {
  181.         // 移除被删除对象的关联
  182.         RemoveAssociations(e.DBObject.Id);
  183.     }

  185.     #endregion
  186. }
封装参数为：AssociationManager.AssocObjects(textId1, () =>{});
  2. namespace HTJ.Arx;

  4. /// <summary>
  5. /// 简化版链式关联管理器 - 使用无参数Action，支持1->2->3链式关联，防止闭环
  6. /// </summary>
  7. public static class AssociationManager
  8. {
  9.     #region 内部结构

  11.     /// <summary>
  12.     /// 关联信息
  13.     /// </summary>
  14.     private class AssociationAction
  15.     {
  16.         public ObjectId TargetId { get; set; }
  17.         public Action? Action { get; set; }
  18.         public string Tag { get; set; } = "";
  19.     }

  21.     // 关联存储：源对象ID -> 关联信息列表
  22.     private static readonly Dictionary<ObjectId, List<AssociationAction>> Associations = new();

  24.     // 防止递归更新的标记集合
  25.     private static readonly HashSet<ObjectId> UpdatingObjects = new();

  27.     // 初始化标志
  28.     private static bool _isInitialized;

  30.     #endregion

  32.     #region 公共API

  34.     /// <summary>
  35.     /// 创建对象关联
  36.     /// </summary>
  37.     /// <param name="sourceId">源对象ID</param>
  38.     /// <param name="targetId">目标对象ID</param>
  39.     /// <param name="action">无参数关联动作</param>
  40.     /// <param name="tag">关联标签</param>
  41.     /// <exception cref="InvalidOperationException">检测到闭环关联时抛出</exception>
  42.     public static void AssocObjects(ObjectId sourceId, ObjectId targetId,
  43.         Action? action, string tag = "")
  44.     {
  45.         EnsureInitialized();

  47.         if (sourceId.IsNull || targetId.IsNull || action == null)
  48.             return;

  50.         // 检查是否会造成闭环
  51.         if (WouldCreateCycle(sourceId, targetId)) throw new InvalidOperationException("创建此关联会导致闭环，这是不允许的");

  53.         // 获取或创建关联列表
  54.         if (!Associations.ContainsKey(sourceId)) Associations[sourceId] = new List<AssociationAction>();

  56.         // 检查是否已存在相同标签的关联
  57.         var existing = Associations[sourceId].FirstOrDefault(a => a.Tag == tag);
  58.         if (existing != null)
  59.             existing.Action = action; // 更新现有关联
  60.         else
  61.             // 添加新关联
  62.             Associations[sourceId].Add(new AssociationAction
  63.             {
  64.                 TargetId = targetId,
  65.                 Action = action,
  66.                 Tag = tag
  67.             });
  68.     }

  70.     /// <summary>
  71.     /// 移除对象的所有关联
  72.     /// </summary>
  73.     private static void RemoveAssociations(ObjectId sourceId)
  74.     {
  75.         Associations.Remove(sourceId);
  76.     }

  78.     /// <summary>
  79.     /// 移除特定标签的关联
  80.     /// </summary>
  81.     public static void RemoveAssociation(ObjectId sourceId, string tag)
  82.     {
  83.         if (!Associations.TryGetValue(sourceId, out var association)) return;
  84.         association.RemoveAll(a => a.Tag == tag);
  85.         if (Associations[sourceId].Count == 0) Associations.Remove(sourceId);
  86.     }

  88.     /// <summary>
  89.     /// 手动触发关联更新
  90.     /// </summary>
  91.     /// <param name="sourceId">源对象ID</param>
  92.     public static void UpdateAssociations(ObjectId sourceId)
  93.     {
  94.         if (!Associations.ContainsKey(sourceId) || UpdatingObjects.Contains(sourceId))
  95.             return;
  96.         ExecuteAssociations(sourceId);
  97.     }

  99.     /// <summary>
  100.     /// 检查是否存在关联
  101.     /// </summary>
  102.     public static bool HasAssociations(ObjectId sourceId)
  103.     {
  104.         return Associations.ContainsKey(sourceId);
  105.     }

  107.     /// <summary>
  108.     /// 获取关联统计信息
  109.     /// </summary>
  110.     public static string GetStats()
  111.     {
  112.         var sourceCount = Associations.Count;
  113.         var totalAssociations = Associations.Values.Sum(list => list.Count);

  115.         return $"关联源对象: {sourceCount}, 总关联数: {totalAssociations}";
  116.     }

  118.     #endregion

  120.     #region 核心实现

  122.     /// <summary>
  123.     /// 确保管理器已初始化
  124.     /// </summary>
  125.     private static void EnsureInitialized()
  126.     {
  127.         if (_isInitialized) return;

  129.         var doc = Acaop.DocumentManager.MdiActiveDocument;
  130.         if (doc != null)
  131.         {
  132.             doc.Database.ObjectModified += OnObjectModified;
  133.             doc.Database.ObjectErased += OnObjectErased;
  134.             _isInitialized = true;
  135.         }
  136.     }

  138.     /// <summary>
  139.     /// 检查是否会造成闭环
  140.     /// </summary>
  141.     private static bool WouldCreateCycle(ObjectId sourceId, ObjectId targetId)
  142.     {
  143.         // 如果目标对象已经是源对象的祖先，则形成闭环
  144.         return IsAncestor(targetId, sourceId, new HashSet<ObjectId>());
  145.     }

  147.     /// <summary>
  148.     /// 检查targetId是否是sourceId的祖先
  149.     /// </summary>
  150.     private static bool IsAncestor(ObjectId sourceId, ObjectId targetId, HashSet<ObjectId> visited)
  151.     {
  152.         if (sourceId == targetId)
  153.             return true;

  155.         if (!visited.Add(sourceId))
  156.             return false;

  158.         if (!Associations.TryGetValue(sourceId, out var association)) return false;
  159.         foreach (var action in association)
  160.             if (IsAncestor(action.TargetId, targetId, visited))
  161.                 return true;

  163.         return false;
  164.     }

  166.     /// <summary>
  167.     /// 执行关联动作
  168.     /// </summary>
  169.     private static void ExecuteAssociations(ObjectId sourceId)
  170.     {
  171.         if (!Associations.ContainsKey(sourceId) || UpdatingObjects.Contains(sourceId))
  172.             return;

  174.         try
  175.         {
  176.             UpdatingObjects.Add(sourceId);

  178.             foreach (var actionInfo in Associations[sourceId].ToList())
  179.                 try
  180.                 {
  181.                     // 执行关联动作
  182.                     actionInfo.Action?.Invoke();
  183.                     // 递归执行链式关联
  184.                     if (Associations.ContainsKey(actionInfo.TargetId))
  185.                         ExecuteAssociations(actionInfo.TargetId);
  186.                 }
  187.                 catch (Exception ex)
  188.                 {
  189.                     Debug.WriteLine($"关联执行失败 [{actionInfo.Tag}]: {ex.Message}");
  190.                 }
  191.         }
  192.         finally
  193.         {
  194.             UpdatingObjects.Remove(sourceId);
  195.         }
  196.     }

  198.     /// <summary>
  199.     /// 对象修改事件处理
  200.     /// </summary>
  201.     private static void OnObjectModified(object sender, ObjectEventArgs e)
  202.     {
  203.         if (!Associations.ContainsKey(e.DBObject.Id) ||
  204.             UpdatingObjects.Contains(e.DBObject.Id))
  205.             return;

  207.         ExecuteAssociations(e.DBObject.Id);
  208.     }

  210.     /// <summary>
  211.     /// 对象删除事件处理
  212.     /// </summary>
  213.     private static void OnObjectErased(object sender, ObjectErasedEventArgs e)
  214.     {
  215.         // 移除被删除对象的关联
  216.         RemoveAssociations(e.DBObject.Id);

  218.         // 移除指向被删除对象的所有关联
  219.         foreach (var sourceId in Associations.Keys.ToList())
  220.         {
  221.             Associations[sourceId].RemoveAll(action => action.TargetId == e.DBObject.Id);
  222.             if (Associations[sourceId].Count == 0) Associations.Remove(sourceId);
  223.         }
  224.     }

  226.     #endregion
  227. }
封装参数为：AssociationManager.AssocObjects(sId,tId, () =>{});

  3.     [CommandMethod("tt8")]
  4.     public void Tt8()
  5.     {
  6.         if (!Env.Editor.SelId(out ObjectId textId1,RxClassEx.DbText))
  7.             return;
  8.         if (!Env.Editor.SelId(out ObjectId circleId,RxClassEx.Circle))
  9.             return;
  10.         if (!Env.Editor.SelId(out ObjectId textId2,RxClassEx.DbText))
  11.             return;
  12.         // 创建图形属性关联
  13.         AssociationManager.AssocObjects(textId1,circleId,() =>
  14.         {
  15.             using var tr = new DBTrans(docLock: false);
  16.             if (tr.GetObject(textId1) is not DBText text1)
  17.                 return;
  18.             if (tr.GetObject(circleId,OpenMode.ForWrite) is not Circle circle)
  19.                 return;
  20.             circle.Radius=text1.TextString.ToDouble();
  21.             circle.ColorIndex=1;
  22.             if (tr.GetObject(textId2,OpenMode.ForWrite) is not DBText text2)
  23.                 return;
  24.             text2.TextString = $"半径: {circle.Radius:F2}";
  25.         },"1->2");
  26.         // 创建关联：文字显示圆的半径和面积
  27.     AssociationManager.AssocObjects(circleId,textId2,() =>
  28.     {
  29.         using var tr = new DBTrans(docLock: false);
  30.         if (tr.GetObject(circleId) is not Circle circle)
  31.             return;
  32.         if (tr.GetObject(textId2,OpenMode.ForWrite) is not DBText text2)
  33.             return;
  34.         text2.TextString = $"半径: {circle.Radius:F2}";
  35.     },"2->3");
测试2


网友答: 关于AssocAction，CAD有自带的，ifox群有我的代码示例

网友答:
  1. namespace HTJ.Arx;

  3. /// <summary>
  4. /// 关联动作体封装
  5. /// BY2025.11;wang2006zhi
  6. /// </summary>
  7. /// <remarks>
  8. /// 使用示例：
  9. /// <code>
  10. /// var logic = new Dictionary{
  11. ///     [textId] = trans => { /* 文字更新逻辑 */ },
  12. ///     [circleId] = trans => { /* 圆更新逻辑 */ }
  13. /// };
  14. /// AssocActionEx.Create(logic);
  15. /// </code>
  16. /// </remarks>
  17. public class AssocActionEx : AssocActionBody
  18. {
  19.     #region 私有字段

  21.     private ObjectId _assocActionId = ObjectId.Null;
  22.     private readonly List<ObjectId> _sourceObjectIds = [];
  23.     private readonly Dictionary<ObjectId, Action<AssocObjectTransaction>> _objectUpdateActions = [];
  24.     private readonly List<Action<AssocObjectTransaction>> _globalUpdateActions = [];
  25.     private Func<AssocActionEx>? _cloneFactory;
  26.     private bool _cloneFlag;

  28.     #endregion

  30.     #region 公共接口

  32.     /// <summary>
  33.     /// 创建关联动作
  34.     /// </summary>
  35.     /// <param name="objectSpecificLogic">
  36.     /// 对象特定逻辑字典，Key为对象ID（自动作为依赖对象），Value为对应的更新逻辑
  37.     /// </param>
  38.     /// <param name="cloneFactory">深克隆时的创建工厂，用于对象复制时创建新的关联动作实例</param>
  39.     /// <returns>创建的关联动作实例</returns>
  40.     /// <exception cref="ArgumentNullException">当逻辑字典为空时抛出</exception>
  41.     /// <exception cref="ArgumentException">当逻辑字典为空时抛出</exception>
  42.     public static AssocActionEx Create(Dictionary<ObjectId, Action<AssocObjectTransaction>> objectSpecificLogic,
  43.         Func<AssocActionEx>? cloneFactory = null)
  44.     {
  45.         if (objectSpecificLogic == null) throw new ArgumentNullException(nameof(objectSpecificLogic));
  46.         if (objectSpecificLogic.Count == 0) throw new ArgumentException(@"对象特定逻辑字典不能为空", nameof(objectSpecificLogic));

  48.         var action = new AssocActionEx();

  50.         if (cloneFactory != null) action._cloneFactory = cloneFactory;

  52.         // 直接从字典的键获取依赖对象，并设置更新逻辑
  53.         action.SetupDependenciesAndLogic(objectSpecificLogic);

  55.         return action;
  56.     }

  58.     /// <summary>
  59.     /// 添加全局更新逻辑（对所有依赖对象生效）
  60.     /// </summary>
  61.     /// <param name="logic">全局更新逻辑，会在每次评估时执行</param>
  62.     /// <returns>当前实例以支持链式调用</returns>
  63.     /// <exception cref="ArgumentNullException">当逻辑为空时抛出</exception>
  64.     public AssocActionEx AddGlobalLogic(Action<AssocObjectTransaction> logic)
  65.     {
  66.         _globalUpdateActions.Add(logic ?? throw new ArgumentNullException(nameof(logic)));
  67.         return this;
  68.     }

  70.     /// <summary>
  71.     /// 设置深克隆工厂函数
  72.     /// </summary>
  73.     /// <param name="factory">创建新实例的工厂函数，在对象被复制时调用</param>
  74.     /// <returns>当前实例以支持链式调用</returns>
  75.     /// <exception cref="ArgumentNullException">当工厂函数为空时抛出</exception>
  76.     public AssocActionEx SetCloneFactory(Func<AssocActionEx> factory)
  77.     {
  78.         _cloneFactory = factory ?? throw new ArgumentNullException(nameof(factory));
  79.         return this;
  80.     }

  82.     #endregion

  84.     #region 内部实现

  86.     /// <summary>
  87.     /// 设置依赖关系并创建关联动作
  88.     /// </summary>
  89.     /// <param name="objectSpecificLogic">对象特定逻辑字典</param>
  90.     private void SetupDependenciesAndLogic(Dictionary<ObjectId, Action<AssocObjectTransaction>> objectSpecificLogic)
  91.     {
  92.         var ids = objectSpecificLogic.Keys.ToList();
  93.         // 设置依赖关系
  94.         SetupDependencies(ids);
  95.         // 设置对象特定逻辑
  96.         foreach (var kv in objectSpecificLogic) _objectUpdateActions[kv.Key] = kv.Value;
  97.     }

  99.     /// <summary>
  100.     /// 获取需要处理的对象列表
  101.     /// </summary>
  102.     /// <param name="transaction">关联事务</param>
  103.     /// <returns>需要更新的对象ID列表</returns>
  104.     private List<ObjectId> GetPendingObjects(AssocObjectTransaction transaction)
  105.     {
  106.         var objectIdCollection = GetDependencies(true, true);
  107.         var pendingObjectIds = new List<ObjectId>(objectIdCollection.Count);

  109.         // 遍历所有依赖项，检查哪些需要更新
  110.         foreach (ObjectId dependencyId in objectIdCollection)
  111.         {
  112.             using var dependency =
  113.                 (AssocDependency)transaction.GetDBObject(dependencyId, OpenMode.ForRead, false, true);

  115.             // 如果依赖项状态不是"已更新"，则添加到待处理列表
  116.             if (dependency.Status != AssocStatus.IsUpToDateAssocStatus)
  117.             {
  118.                 pendingObjectIds.Add(dependency.DependentOnObject);
  119.             }
  120.         }

  122.         return pendingObjectIds;
  123.     }

  125.     /// <summary>
  126.     /// 获取或创建关联动作对象
  127.     /// </summary>
  128.     /// <param name="owningObjectId">所属对象ID</param>
  129.     /// <param name="tr">数据库事务</param>
  130.     /// <returns>关联动作对象</returns>
  131.     private AssocAction GetOrCreateAssocAction(ObjectId owningObjectId, DBTrans tr)
  132.     {
  133.         // 如果已经存在关联动作，直接返回
  134.         if (!_assocActionId.IsNull) return tr.GetObject<AssocAction>(_assocActionId, OpenMode.ForWrite)!;

  136.         var database = tr.Database;

  138.         // 获取或创建关联网络
  139.         var networkObjectId = AssocNetwork.GetInstanceFromObject(owningObjectId, true, true, "");
  140.         var network = tr.GetObject<AssocNetwork>(networkObjectId, OpenMode.ForWrite)!;

  142.         // 创建关联动作
  143.         var assocAction = new AssocAction();
  144.         var actionBodyObjectId = database.AddDBObject(this);

  146.         // 注册新创建的对象到事务中
  147.         tr.Transaction.AddNewlyCreatedDBObject(this, true);
  148.         _assocActionId = database.AddDBObject(assocAction);
  149.         assocAction.ActionBody = actionBodyObjectId;
  150.         network.AddAction(_assocActionId, true);

  152.         return assocAction;
  153.     }

  155.     /// <summary>
  156.     /// 评估逻辑 - 执行所有注册的更新动作
  157.     /// </summary>
  158.     /// <remarks>
  159.     /// 这是关联动作的核心方法，当依赖对象发生变化时自动调用
  160.     /// </remarks>
  161.     public override void EvaluateOverride()
  162.     {
  163.         try
  164.         {
  165.             var assocEvaluationCallback = currentEvaluationCallback();

  167.             // 检查评估模式是否为"修改对象"模式
  168.             if (assocEvaluationCallback.EvaluationMode() != AssocEvaluationMode.ModifyObjectsAssocEvaluationMode)
  169.             {
  170.                 Status = AssocStatus.FailedToEvaluateAssocStatus;
  171.                 return;
  172.             }

  174.             // 检查是否存在被删除或损坏的依赖项
  175.             if (HasAnyErasedOrBrokenDependencies())
  176.             {
  177.                 Status = AssocStatus.ErasedAssocStatus;
  178.                 return;
  179.             }

  181.             using var transaction = new AssocObjectTransaction(this);

  183.             // 获取需要更新的对象
  184.             var pendingObjects = GetPendingObjects(transaction);
  185.             if (pendingObjects.Count == 0)
  186.             {
  187.                 Status = AssocStatus.IsUpToDateAssocStatus;
  188.                 return;
  189.             }

  191.             // 评估依赖项状态
  192.             EvaluateDependencies();

  194.             // 执行对象特定的更新逻辑
  195.             ExecuteObjectSpecificLogic(pendingObjects, transaction);

  197.             // 执行全局更新逻辑
  198.             ExecuteGlobalLogic(transaction);

  200.             // 标记状态为已更新
  201.             Status = AssocStatus.IsUpToDateAssocStatus;
  202.         }
  203.         catch (Exception ex)
  204.         {
  205.             // 记录异常并标记为评估失败
  206.             $"关联动作评估失败: {ex.Message}".Print();
  207.             Status = AssocStatus.FailedToEvaluateAssocStatus;
  208.         }
  209.     }

  211.     /// <summary>
  212.     /// 执行对象特定的更新逻辑
  213.     /// </summary>
  214.     /// <param name="pendingObjects">待处理对象列表</param>
  215.     /// <param name="transaction">关联事务</param>
  216.     private void ExecuteObjectSpecificLogic(List<ObjectId> pendingObjects, AssocObjectTransaction transaction)
  217.     {
  218.         foreach (var objectId in pendingObjects)
  219.         {
  220.             if (!_objectUpdateActions.TryGetValue(objectId, out var objectLogic)) continue;
  221.             try
  222.             {
  223.                 objectLogic(transaction);
  224.             }
  225.             catch (Exception ex)
  226.             {
  227.                $"对象特定逻辑执行失败 {objectId}: {ex.Message}".Print();;
  228.             }
  229.         }
  230.     }

  232.     /// <summary>
  233.     /// 执行全局更新逻辑
  234.     /// </summary>
  235.     /// <param name="transaction">关联事务</param>
  236.     private void ExecuteGlobalLogic(AssocObjectTransaction transaction)
  237.     {
  238.         foreach (var globalLogic in _globalUpdateActions)
  239.         {
  240.             try
  241.             {
  242.                 globalLogic(transaction);
  243.             }
  244.             catch (Exception ex)
  245.             {
  246.                 $"全局逻辑执行失败: {ex.Message}".Print();
  247.             }
  248.         }
  249.     }

  251.     /// <summary>
  252.     /// 深克隆处理 - 当关联对象被复制时调用
  253.     /// </summary>
  254.     /// <param name="idMap">对象ID映射关系</param>
  255.     /// <param name="additionalObjectsToClone">额外需要克隆的对象集合</param>
  256.     /// <remarks>
  257.     /// 此方法确保当依赖对象被复制时，关联动作也会被正确复制
  258.     /// </remarks>
  259.     public override void AddMoreObjectsToDeepCloneOverride(IdMapping idMap, ObjectIdCollection additionalObjectsToClone)
  260.     {
  261.         if (_cloneFlag) return;
  262.         _cloneFlag = true;
  263.         try
  264.         {
  265.             using var tr = new DBTrans();
  266.             // 收集已克隆的对象ID
  267.             var (clonedIds, originalIds) = CollectClonedIds(idMap);
  268.             // 克隆缺失的依赖对象
  269.             CloneMissingDependencies(clonedIds, originalIds, tr);
  270.             // 创建新的关联动作实例并复制逻辑
  271.             CreateClonedActionBody(clonedIds, idMap);
  272.         }
  273.         finally
  274.         {
  275.             _cloneFlag = false;
  276.         }
  277.     }

  279.     /// <summary>
  280.     /// 收集已克隆的对象ID
  281.     /// </summary>
  282.     /// <param name="idMap">ID映射表</param>
  283.     /// <returns>克隆后的ID列表和原始ID列表</returns>
  284.     private (List<ObjectId> clonedIds, List<ObjectId> originalIds) CollectClonedIds(IdMapping idMap)
  285.     {
  286.         var length = idMap.GetValues().Count;
  287.         var clonedIds = new List<ObjectId>(length);
  288.         var originalIds = new List<ObjectId>(length);

  290.         foreach (IdPair idPair in idMap)
  291.         {
  292.             clonedIds.Add(idPair.Value);
  293.             originalIds.Add(idPair.Key);
  294.         }

  296.         return (clonedIds, originalIds);
  297.     }

  299.     /// <summary>
  300.     /// 克隆缺失的依赖对象
  301.     /// </summary>
  302.     /// <param name="clonedIds">已克隆的ID列表</param>
  303.     /// <param name="originalIds">原始ID列表</param>
  304.     /// <param name="tr">数据库事务</param>
  305.     private void CloneMissingDependencies(List<ObjectId> clonedIds, List<ObjectId> originalIds, DBTrans tr)
  306.     {
  307.         // 检查是否有缺失的依赖对象需要克隆
  308.         if (clonedIds.Count >= _sourceObjectIds.Count) return;

  310.         var missingIds = _sourceObjectIds.Except(originalIds).ToArray();
  311.         if (missingIds.Length == 0) return;

  313.         // 执行深克隆操作
  314.         var objectIdCollection = new ObjectIdCollection(missingIds);
  315.         using var idMapping = new IdMapping();

  317.         tr.Database.DeepCloneObjects(objectIdCollection, tr.CurrentSpace.ObjectId, idMapping, false);

  319.         // 添加新克隆的对象ID到列表中
  320.         foreach (IdPair idPair in idMapping)
  321.         {
  322.             clonedIds.Add(idPair.Value);
  323.         }
  324.     }

  326.     private void CreateClonedActionBody(List<ObjectId> clonedIds, IdMapping idMap)
  327.     {
  328.         // 创建新的动作体实例
  329.         var newBody = _cloneFactory?.Invoke() ?? new AssocActionEx();

  331.         // 设置依赖关系（使用克隆后的ID列表）
  332.         newBody.SetupDependencies(clonedIds);

  334.         // 复制对象特定逻辑（映射到克隆后的对象ID）
  335.         foreach (var kv in _objectUpdateActions)
  336.         {
  337.             var originalId = kv.Key;
  338.             var logic = kv.Value;
  339.             var clonedId = FindClonedId(originalId, idMap);
  340.             if (clonedId.IsValid) newBody._objectUpdateActions[clonedId] = logic;
  341.         }

  343.         // 复制全局逻辑
  344.         newBody._globalUpdateActions.AddRange(_globalUpdateActions);
  345.     }

  347.     /// <summary>
  348.     /// 设置依赖关系
  349.     /// </summary>
  350.     /// <param name="ids">依赖对象ID列表</param>
  351.     private void SetupDependencies(IList<ObjectId> ids)
  352.     {
  353.         if (ids.Count == 0) return;

  355.         using var tr = new DBTrans();
  356.         var first = ids[0];
  357.         var database = first.Database;

  359.         // 验证数据库状态
  360.         if (database == null)
  361.         {
  362.             "数据库不可用".Print();
  363.             return;
  364.         }
  365.         // 获取或创建关联动作
  366.         var assocAction = GetOrCreateAssocAction(first, tr);

  368.         // 在事务中创建依赖关系
  369.         using var transaction = database.TransactionManager.StartTransaction();

  371.         for (int i = 0; i < ids.Count; i++)
  372.         {
  373.             var entityId = ids;
  374.             if (!IsObjectSuitableForAssociation(entityId, tr))
  375.             {
  376.                 $"对象 {entityId} 不适合作为关联依赖，已跳过".Print();
  377.                 continue;
  378.             }
  379.             _sourceObjectIds.Add(entityId);

  381.             // 创建依赖项
  382.             var dependency = new AssocDependency();
  383.             var dependencyId = database.AddDBObject(dependency);

  385.             // 配置依赖项属性
  386.             dependency.AttachToObject(new CompoundObjectId(entityId));
  387.             dependency.IsReadDependency = true;
  388.             dependency.IsWriteDependency = true;
  389.             dependency.Order = i;

  391.             // 将依赖项添加到关联动作
  392.             assocAction.AddDependency(dependencyId, true);
  393.         }

  395.         transaction.Commit();
  396.     }

  398.     /// <summary>
  399.     /// 检查对象是否适合作为关联依赖
  400.     /// </summary>
  401.     private bool IsObjectSuitableForAssociation(ObjectId objectId, DBTrans tr)
  402.     {
  403.         try
  404.         {
  405.             if (objectId.IsNull || !objectId.IsValid)
  406.                 return false;

  408.             using var obj = tr.Transaction.GetObject(objectId, OpenMode.ForRead, false, true);
  409.         
  410.             // 检查对象类型
  411.             if (obj is BlockReference || obj is BlockTableRecord)
  412.             {
  413.                 "块引用和块表记录不适合作为关联依赖".Print();
  414.                 return false;
  415.             }

  417.             // 检查对象是否已被擦除
  418.             if (obj.IsErased)
  419.             {
  420.                 "对象已被擦除".Print();
  421.                 return false;
  422.             }

  424.             return true;
  425.         }
  426.         catch
  427.         {
  428.             return false;
  429.         }
  430.     }
  431.     /// <summary>
  432.     /// 查找克隆后的对象ID
  433.     /// </summary>
  434.     /// <param name="originalId">原始对象ID</param>
  435.     /// <param name="idMap">ID映射表</param>
  436.     /// <returns>克隆后的对象ID，如果找不到则返回ObjectId.Null</returns>
  437.     private static ObjectId FindClonedId(ObjectId originalId, IdMapping idMap)
  438.     {
  439.         foreach (IdPair idPair in idMap)
  440.         {
  441.             if (idPair.Key == originalId) return idPair.Value;
  442.         }

  444.         return ObjectId.Null;
  445.     }

  447.     #endregion
  448. }


网友答:
  2. namespace HTJ.Arx;

  4. /// <summary>
  5. /// 封装的动作体基类
  6. /// BY 徐蕾来自IFOX
  7. /// </summary>
  8. public abstract class AssocActionEx : AssocActionBody
  9. {
  10.     /// <summary>
  11.     /// 所在的动作的objectid
  12.     /// </summary>
  13.     private ObjectId AssocActionId { get; set; } = ObjectId.Null;

  15.     /// <summary>
  16.     /// 外部传入的对象id缓存
  17.     /// </summary>
  18.     private readonly List<ObjectId> _sourceObjectIds = [];
  19.    
  20.     /// <summary>
  21.     /// 添加依赖到动作中
  22.     /// </summary>
  23.     /// <param name="tr"></param>
  24.     /// <param name="isRead"></param>
  25.     /// <param name="isWrite"></param>
  26.     /// <param name="ids"></param>
  27.     public virtual void AddDependency(IList<ObjectId> ids, DBTrans tr, bool isRead = true, bool isWrite = true)
  28.     {
  29.         if (!ids.Any()) return;
  30.         var first = ids.First();
  31.         var database = first.Database;
  32.         // 假设 GetAssocAction 已经通过事务获取对象
  33.         AssocAction assocAction = GetAssocAction(first, tr);
  34.         // 确保在事务内部执行所有操作
  35.         using Transaction transaction = database.TransactionManager.StartTransaction();
  36.         for (int i = 0; i < ids.Count; i++)
  37.         {
  38.             var entity = ids[i];
  39.             _sourceObjectIds.Add(entity);
  40.             
  41.             var dependency = new AssocDependency();
  42.             var dependecyId = database.AddDBObject(dependency);
  43.             
  44.             dependency.AttachToObject(new CompoundObjectId(entity));
  45.             dependency.IsReadDependency = isRead;
  46.             dependency.IsWriteDependency = isWrite;
  47.             dependency.Order = i;
  48.             
  49.             assocAction.AddDependency(dependecyId, true);
  50.         }
  51.         transaction.Commit();
  52.     }


  55.     /// <summary>
  56.     /// 生成子类实例的抽象方法,用于实体复制事件中的占位
  57.     /// </summary>
  58.     /// <returns></returns>
  59.     protected abstract AssocActionEx CreateAssocActionBody();
  60.    
  61.     /// <summary>
  62.     /// 具体的更新实体逻辑
  63.     /// </summary>
  64.     /// <param name="objectId"></param>
  65.     /// <param name="aTransaction"></param>
  66.     protected abstract void UpdateEntity(ObjectId objectId, AssocObjectTransaction aTransaction);
  67.    
  68.     /// <summary>
  69.     /// 获取动作
  70.     /// </summary>
  71.     /// <param name="owningObjectId">要查找关联网络的对象的 OwnerId（通常是块表记录或字典的 ID）</param>
  72.     /// <param name="tr"></param>
  73.     /// <returns></returns>
  74.     /// <exception cref="InvalidOperationException"></exception>
  75.     private AssocAction GetAssocAction(ObjectId owningObjectId, DBTrans tr)
  76.     {
  77.         if (!AssocActionId.IsNull) return tr.GetObject<AssocAction>(AssocActionId, OpenMode.ForWrite)!;
  78.         var database = tr.Database;
  79.         //获取或创建关联网络的objectid
  80.         //第一个false表示没有就创建新的
  81.         //第二个true表示加入顶级网路(不明所以)
  82.         var networkObjectid = AssocNetwork.GetInstanceFromObject(owningObjectId, true, true, "");
  83.         // 以写入模式获取网络对象
  84.         var network = tr.GetObject<AssocNetwork>(networkObjectid, OpenMode.ForWrite)!;
  85.         // 创建关联动作对象
  86.         var assocAction = new AssocAction();

  88.         // 将动作体添加到数据库
  89.         var actionBodyObjectid = database.AddDBObject(this);
  90.         // 在事务中注册新创建的动作体
  91.         tr.Transaction.AddNewlyCreatedDBObject(this, true);
  92.         // 将动作添加到数据库
  93.         AssocActionId = database.AddDBObject(assocAction);
  94.         // 关联动作对象设置其动作体
  95.         assocAction.ActionBody = actionBodyObjectid;
  96.         // 将动作添加到网络中
  97.         network.AddAction(AssocActionId, true);
  98.         return assocAction;
  99.     }

  101.     /// <summary>
  102.     /// 获取实体上包含的动作
  103.     /// </summary>
  104.     /// <param name="entity"></param>
  105.     /// <param name="tr"></param>
  106.     /// <returns></returns>
  107.     /// <exception cref="InvalidOperationException"></exception>
  108.     private AssocAction GetAssocAction(Entity entity, DBTrans tr)
  109.     {
  110.         return !entity.ObjectId.IsOk() ? throw new InvalidOperationException() : GetAssocAction(entity.OwnerId, tr);
  111.     }
  112.    
  113.     /// <summary>
  114.     /// 重写 AssocActionBody 的 EvaluateOverride 方法，用于自定义关联动作的评估逻辑
  115.     /// </summary>
  116.     public override void EvaluateOverride()
  117.     {
  118.         // 获取当前关联评估的回调接口
  119.         var assocEvaluationCallback = currentEvaluationCallback();

  121.         // 检查评估模式是否为"修改对象"模式，如果不是则标记为失败并退出
  122.         if (assocEvaluationCallback.EvaluationMode() != AssocEvaluationMode.ModifyObjectsAssocEvaluationMode)
  123.         {
  124.             Status = AssocStatus.FailedToEvaluateAssocStatus;
  125.             return;
  126.         }

  128.         // 检查是否存在被删除或损坏的依赖项，如果是则标记为"已删除"状态并退出
  129.         if (HasAnyErasedOrBrokenDependencies())
  130.         {
  131.             Status = AssocStatus.ErasedAssocStatus;
  132.             return;
  133.         }

  135.         // 创建一个关联对象事务（自动释放资源）
  136.         using var transaction = new AssocObjectTransaction(this);

  138.         // 获取所有依赖项（包括直接和间接依赖）
  139.         var objectIdCollection = GetDependencies(true, true);

  141.         //标记是否需要更新
  142.         bool isUpToDateAssocStatus = true;

  144.         //待处理的实体id集合
  145.         List<ObjectId> pendingObjectids = [];

  147.         foreach (ObjectId objectId in objectIdCollection)
  148.         {
  149.             // 以只读方式打开依赖项（AssocDependency 对象）
  150.             using AssocDependency dependency = (AssocDependency)transaction.GetDBObject(objectId, OpenMode.ForRead, false, true);
  151.             if (dependency.Status is AssocStatus.IsUpToDateAssocStatus) continue;
  152.             isUpToDateAssocStatus = false;
  153.             pendingObjectids.Add(dependency.DependentOnObject);
  154.         }

  156.         // 显式评估所有依赖项的状态
  157.         EvaluateDependencies();

  159.         // 如果依赖项都已是最新状态，则直接标记为最新并退出
  160.         if (isUpToDateAssocStatus)
  161.         {
  162.             Status = AssocStatus.IsUpToDateAssocStatus;
  163.             return;
  164.         }

  166.         //各个子类实现相应的动作
  167.         //UpdateEntity(pendingObjectids, transaction);

  169.         foreach (ObjectId objectId in pendingObjectids)
  170.         {
  171.             UpdateEntity(objectId, transaction);
  172.         }

  174.         // 标记当前状态为"已更新"
  175.         Status = AssocStatus.IsUpToDateAssocStatus;
  176.     }


  179.     private bool _cloneFlag;

  181.     public override void AddMoreObjectsToDeepCloneOverride(IdMapping idMap, ObjectIdCollection additionalObjectsToClone)
  182.     {
  183.         if (_cloneFlag) return;

  185.         using var tr = new DBTrans();

  187.         List<ObjectId> ids = [];
  188.         List<ObjectId> objectids = [];
  189.         foreach (IdPair idPair in idMap)
  190.         {
  191.             ids.Add(idPair.Value);
  192.             objectids.Add(idPair.Key);
  193.         }

  195.         if (ids.Count < _sourceObjectIds.Count)
  196.         {
  197.             var except = _sourceObjectIds.Except(objectids).ToArray();
  198.             var objectIdCollection = new ObjectIdCollection(except);
  199.             using IdMapping idMapping = [];

  201.             _cloneFlag = true;
  202.             //深度克隆
  203.             tr.Database.DeepCloneObjects(objectIdCollection, tr.CurrentSpace.ObjectId, idMapping, false);
  204.             _cloneFlag = false;

  206.             foreach (IdPair idPair in idMapping)
  207.             {
  208.                 ids.Add(idPair.Value);
  209.             }
  210.         }
  211.         // 创建自定义动作体实例
  212.         var body = this.CreateAssocActionBody();
  213.         //添加依赖
  214.         body.AddDependency(ids, tr);

  216.     }
  217.    
  218. }记录一下


网友答: 发个图片看看呀

网友答: 本帖最后由 wang2006zhi 于 2025-11-5 13:16 编辑
  1. 演示
复制代码


网友答:
d1742647821 发表于 2025-11-4 11:44
关于AssocAction，CAD有自带的，ifox群有我的代码示例

经过提醒，在IFOX群里找到了相关示例。。。基于此，本文不再设置付费主题观看

网友答: 本帖最后由 你有种再说一遍 于 2025-11-4 15:59 编辑

标注关联有没有做过?我发现官方在标注关联是有bug的,例如跨空间标注关联,然后我们要附着岂不是有相同bug?

网友答:
你有种再说一遍 发表于 2025-11-4 15:49
标注关联有没有做过?我发现官方在标注关联是有bug的,例如跨空间标注关联,然后我们要附着岂不是有相同bug?

没有，目前没这方面的业务需求

网友答: 作者怎么被封啦???也没有看他刷帖啊
  • 上一篇：[求助]基于中望WebCAD的二次开发
  • 下一篇：没有了
    CAD技术交流中心 | 建筑CAD | 给排水CAD | 暖通CAD | 电气CAD | 电力CAD | 机械CAD | CAD母线槽 | CAD看图
    Copyright © 2019 - 2025