Community
Nested transactions themself do not crash AutoCAD and can be used if necessary. It is other factor/factors in your code that crash AutoCAD. For example, this code worked OK:
[CommandMethod("TransTest",CommandFlags.UsePickSet)]
public static void TestRun()
{
Document dwg = Autodesk.AutoCAD.ApplicationServices.
Application.DocumentManager.MdiActiveDocument;
//Make sure there are at least 2 entities selected
PromptSelectionResult res=dwg.Editor.SelectImplied();
if (res.Status != PromptStatus.OK) return;
DoTransaction(dwg,res.Value.GetObjectIds());
}
private static void DoTransaction(Document dwg, ObjectId[] ids)
{
using (Transaction tran = dwg.Database.TransactionManager.StartTransaction())
{
Entity ent = (Entity)tran.GetObject(ids[0], OpenMode.ForRead);
dwg.Editor.WriteMessage("\nFirst entity opened in TRANS1 is {0}", ent.GetType().Name);
DoNestedTransaction(dwg, ids);
tran.Commit();
}
}
private static void DoNestedTransaction(Document dwg, ObjectId[] ids)
{
using (Transaction tran = dwg.Database.TransactionManager.StartTransaction())
{
Entity ent = (Entity)tran.GetObject(ids[ids.Length-1], OpenMode.ForRead);
dwg.Editor.WriteMessage("\nLast entity opened in TRANS2 is {0}", ent.GetType().Name);
tran.Commit();
}
}
So, it depends what you do in the function that wrapped with transaction. For example, were you trying to open the same DBObject in more than 1 transaction?
I assume you are taking about Database.ObjectModified event?
Were you trying to modify DBObject (either passed in by e.DbObject, or other DBObject in the database) in the event handler? If so, it would cause Database.ObjectModified event fires again, then your code in the event handler runs again, then ObjectModified event fires...then..again and again, endless.
Well, you may have some sort of flag set, so that your code in the ObjectModified event handler would only run once in certain condition, so to avoid the endless dead loop. Nonetheless, in many cases, change/modify DBObject in Database.ObjectModified event handler is dangerous.
By the way, If you do something like:
//Somewhere, you registered the event handler
theDb.ObjectModified += new ObjectEventHandler(DB_ObjectModified);
void DoTransaction()
{
using (Transaction tran=....StartTransaction())
{
//Open DBObject and change it
tran.Commit();
}
}
void DB_ObjectModified(object sender, ObjectEventArgs e)
{
....
//Start another transaction, only when a flag is not set
using (Transaction tran=....StartTransaction())
{
}
}
The transaction in the ObjectModified event handler IS NOT a nested Transaction underneath the other transaction, because the ObjectModified event ONLY fires when the first transaction is commited (so the DBObject has been modified).
So, if your code crash AutoCAD, is something you do logically wrong, not because of transaction. Without knowing what exactly you want to achieve and what the code is, it is hard to comment more.
The other often being overlooked issue is that the event handler registered to the database (e.g. theDB.ObjectModified +=....) is not removed correctly at some point of the code's process, and it could be registered many times by repeatedly run a piece of improperly written code, thus even one DBObject is modified, the event could fire many times and handled many times. This may cause some issues, depending on the code in the event handler.
Have you debugged the code, stepping through the code in the event handler? Which line of code causes the crash? Or is that TransactionManager.StartTransaction() causes the crash (since you said: "the transaction in the event cannot be started.")?
As the code in my previous reply showed, a transaction can be started in the ObjectModified event handler, at least my simple code example works as expected. So, you need to clarify what does that mean "the transaction in the event cannot be started".
Is it possible that at least the first time the code in the event handler run past the StartTransaction()? The reason I ask this is because I do see possible logic issues with your cdoe:
1. Is this your intention that ANY blockreference in the database would result in all entities in "clinkobject" colletion to be moved? Well it could be so if all BlockReferences in the drawing is your linked objects. If there is BlockReference not belonging to the linked entities, your code should identify it before going on to change other linked entities.
2. the "foreach...in clinkobject" in wrapped in the transaction is likely wrong: I'd imagine the first linked object that triggers the transaction in ObjectModified event handler should also be in the collection "clinkobject", should it not? If so, then that very object is then moved again, that in tern causes the event fires and code in the event handler to run again. Actually, even the first object is not in the collection, the chain action would still occurs endlessly, as long as one of the linked object is BlockReference.
Your code would only work when the first linked object, which triggers the ObjectModified event, is the ONLY BlockReference in the drawing AND IS NOT IN the "clinkobject" collection. Otherwise the code would run endlessly to crash AutoCAD.
