eWasErased - Whenever I run the C# macro more than once

[bsaidiDG51]

I have a macro that is responsible of updating the block definition of a certain block by inserting the new block definition into the drawing database and then syncing the block references with the new definition.

Everything works fine, my only issue is that when I try to execute the macro twice or more on the same drawing, It crashes and outputs the error message below. But If I execute it once, save the drawing, close it, reopen it,  and then reexecute the macro, it works. So the issue is that I can never execute the macro twice in a row on the same drawing during the same "opening".

I believe it got to do with the database memory/content not being updated/refreshed after the first run which affects the following executions, but I couldn't figure out how to resolve it.

************** Exception Text **************
Autodesk.AutoCAD.Runtime.Exception: eWasErased
   at Autodesk.AutoCAD.DatabaseServices.TransactionManager.GetObjectInternal(AcDbTransactionManager* pTM, ObjectId id, OpenMode mode, Boolean openErased, Boolean forceOpenOnLockedLayer)
   at Autodesk.AutoCAD.DatabaseServices.Transaction.GetObject(ObjectId id, OpenMode mode)
   at EWasErased.Functions.<>c__DisplayClass3_0.<GetAttributesReference>b__0(ObjectId id) in P:\ingenierie\Menu AutoCAD MNS\EWasErased\Functions.cs:line 46
   at System.Linq.Enumerable.WhereSelectEnumerableIterator`2.MoveNext()
   at System.Linq.Enumerable.<OfTypeIterator>d__95`1.MoveNext()
   at EWasErased.Class1.ResetAttributes(BlockReference blockReference, IEnumerable`1 attributeDefinitions, Transaction transaction) in P:\ingenierie\Menu AutoCAD MNS\EWasErased\Class1.cs:line 95
   at EWasErased.Class1.SynchronizeAttributes(BlockTableRecord blockTableRecord, Transaction transaction) in P:\ingenierie\Menu AutoCAD MNS\EWasErased\Class1.cs:line 65
   at EWasErased.Class1.SynchronizeBlockReferencesAttributes(Database db, String blockName) in P:\ingenierie\Menu AutoCAD MNS\EWasErased\Class1.cs:line 52
   at EWasErased.Class1.CommandMethod() in P:\ingenierie\Menu AutoCAD MNS\EWasErased\Class1.cs:line 35
   at Autodesk.AutoCAD.Runtime.CommandClass.InvokeWorker(MethodInfo mi, Object commandObject, Boolean bLispFunction)
   at Autodesk.AutoCAD.Runtime.CommandClass.InvokeWorkerWithExceptionFilter(MethodInfo mi, Object commandObject, Boolean bLispFunction)
   at Autodesk.AutoCAD.Runtime.CommandClass.CommandThunk.Invoke()

The macro code:

[CommandMethod("TEST")]
public static void CommandMethod()
{
    Document document = Application.DocumentManager.MdiActiveDocument;
    Database database = document.Database;
    Editor editor = document.Editor;

    string blockName = "8x11Materiel";

    var blockFile = $@"{ResourcesFolderPath}\{blockName}.dwg";

    using (var sourceDb = new Database(false, true))
    {
        sourceDb.ReadDwgFile(blockFile, FileOpenMode.OpenForReadAndAllShare, false, null);
        database.Insert(blockName, sourceDb, false);
    }

    SynchronizeBlockReferencesAttributes(database, blockName);

    editor.Regen(); // Refresh UI.
}

public static void SynchronizeBlockReferencesAttributes(Database db, string blockName)
{
    using Transaction transaction = db.TransactionManager.StartTransaction();

    // Get the block definition
    var blockTable = (BlockTable)transaction.GetObject(db.BlockTableId, OpenMode.ForRead);
    if (!blockTable.Has(blockName))
    {
        return;
    }
    var blockDefinition = (BlockTableRecord)transaction.GetObject(blockTable[blockName], OpenMode.ForWrite);

    SynchronizeAttributes(blockDefinition, transaction);

    transaction.Commit();
}

public static void SynchronizeAttributes(BlockTableRecord blockTableRecord, Transaction transaction)
{
    if (blockTableRecord == null)
        throw new ArgumentNullException(nameof(blockTableRecord));

    var attributeDefinitions = blockTableRecord.GetAttributesDefinition(transaction, OpenMode.ForRead);
    if (attributeDefinitions == null || !attributeDefinitions.Any())
    {
        return;
    }
    foreach (BlockReference br in blockTableRecord.GetBlockReferences(transaction, OpenMode.ForWrite))
    {
        ResetAttributes(br, attributeDefinitions, transaction);
    }

    if (!blockTableRecord.IsDynamicBlock)
    {
        return;
    }

    // Update the anonymous block definitions created to support this dynamic block
    blockTableRecord.UpdateAnonymousBlocks();
    foreach (BlockTableRecord btr in blockTableRecord.GetAnonymousBlockDefinitions(transaction, OpenMode.ForWrite))
    {
        attributeDefinitions = blockTableRecord.GetAttributesDefinition(transaction, OpenMode.ForRead);
        foreach (BlockReference br in btr.GetBlockReferences(transaction, OpenMode.ForWrite))
        {
            ResetAttributes(br, attributeDefinitions, transaction);
        }
    }
}

public static void ResetAttributes(BlockReference blockReference, IEnumerable<AttributeDefinition> attributeDefinitions, Transaction transaction)
{
    if (blockReference == null)
        throw new ArgumentNullException(nameof(blockReference));
    if (attributeDefinitions == null)
        throw new ArgumentNullException(nameof(attributeDefinitions));

    var attributeValues = new Dictionary<string, string>();
    foreach (AttributeReference attributeReference in blockReference.GetAttributesReference(transaction, OpenMode.ForWrite))
    {
        attributeValues
            .Add(
                attributeReference.Tag,
                attributeReference.IsMTextAttribute ? attributeReference.MTextAttribute.Contents : attributeReference.TextString
            );
        attributeReference.Erase();
    }

    foreach (AttributeDefinition attributeDefinition in attributeDefinitions)
    {
        var attributeReference = new AttributeReference();
        attributeReference.SetAttributeFromBlock(attributeDefinition, blockReference.BlockTransform);

        blockReference.AttributeCollection.AppendAttribute(attributeReference);
        blockReference.Database.TransactionManager.AddNewlyCreatedDBObject(attributeReference, true);
    }
}

[ActivistInvestor]

You're asking someone to diagnose an exception that's occurring in a method that you don't show (GetAttributesDefinition()).

Show the method.

Also, confirm if the failure is occurring when the block is a dynamic block, a non-dynamic block, or either.

[_gile · Accepted solution]

Hi,

It looks like you're using some methods inspired by the ones defined in Gile.AutoCAD.Extension library.

You can either reference this library or try with these extension methods simply extracted from this library.

public static class ExtensionMethods
{
    /// <summary>
    /// Opens the objects which type matches to the given one, and return them.
    /// </summary>
    /// <typeparam name="T">Type of objects to return.</typeparam>
    /// <param name="source">Instance to which the method applies.</param>
    /// <param name="tr">Transaction or OpenCloseTransaction to use.</param>
    /// <param name="mode">Open mode to obtain in.</param>
    /// <param name="openErased">Value indicating whether to obtain erased objects.</param>
    /// <param name="forceOpenOnLockedLayers">Value indicating if locked layers should be opened.</param>
    /// <returns>The sequence of opened objects.</returns>
    /// <exception cref="System.ArgumentNullException">Thrown if <paramref name ="source"/> is null.</exception>
    /// <exception cref="System.ArgumentNullException">Thrown if <paramref name ="tr"/> is null.</exception>
    public static IEnumerable<T> GetObjects<T>(
        this ObjectIdCollection source,
        Transaction tr,
        OpenMode mode = OpenMode.ForRead,
        bool openErased = false,
        bool forceOpenOnLockedLayers = false)
        where T : DBObject
    {
        System.ArgumentNullException.ThrowIfNull(source);
        System.ArgumentNullException.ThrowIfNull(tr);

        if (0 < source.Count)
        {
            var rxClass = RXObject.GetClass(typeof(T));
            foreach (ObjectId id in source)
            {
                if ((id.ObjectClass == rxClass || id.ObjectClass.IsDerivedFrom(rxClass)) &&
                    (!id.IsErased || openErased))
                {
                    yield return (T)tr.GetObject(id, mode, openErased, forceOpenOnLockedLayers);
                }
            }
        }
    }

    /// <summary>
    /// Opens the attribute references in the given open mode.
    /// </summary>
    /// <param name="source">Attribute collection.</param>
    /// <param name="tr">Transaction or OpenCloseTransaction to use.</param>
    /// <param name="mode">Open mode to obtain in.</param>
    /// <param name="openErased">Value indicating whether to obtain erased objects.</param>
    /// <param name="forceOpenOnLockedLayers">Value indicating if locked layers should be opened.</param>
    /// <returns>The sequence of attribute references.</returns>
    /// <exception cref="System.ArgumentNullException">Thrown if <paramref name ="source"/> is null.</exception>
    /// <exception cref="System.ArgumentNullException">Thrown if <paramref name ="tr"/> is null.</exception>
    public static IEnumerable<AttributeReference> GetObjects(
        this AttributeCollection source,
        Transaction tr,
        OpenMode mode = OpenMode.ForRead,
        bool openErased = false,
        bool forceOpenOnLockedLayers = false)
    {
        System.ArgumentNullException.ThrowIfNull(source);
        System.ArgumentNullException.ThrowIfNull(tr);

        if (source.Count > 0)
        {
            foreach (ObjectId id in source)
            {
                if (!id.IsErased || openErased)
                {
                    yield return (AttributeReference)tr.GetObject(id, mode, openErased, forceOpenOnLockedLayers);
                }
            }
        }
    }

    /// <summary>
    /// Opens the entities which type matches to the given one, and return them.
    /// </summary>
    /// <typeparam name="T">Type of objects to return.</typeparam>
    /// <param name="btr">Block table record.</param>
    /// <param name="tr">Transaction or OpenCloseTransaction to use.</param>
    /// <param name="mode">Open mode to obtain in.</param>
    /// <param name="openErased">Value indicating whether to obtain erased objects.</param>
    /// <param name="forceOpenOnLockedLayers">Value indicating if locked layers should be opened.</param>
    /// <returns>The sequence of opened objects.</returns>
    /// <exception cref="System.ArgumentNullException">Thrown if <paramref name ="btr"/> is null.</exception>
    /// <exception cref="System.ArgumentNullException">Thrown if <paramref name ="tr"/> is null.</exception>
    public static IEnumerable<T> GetObjects<T>(
      this BlockTableRecord btr,
      Transaction tr,
      OpenMode mode = OpenMode.ForRead,
      bool openErased = false,
      bool forceOpenOnLockedLayers = false) where T : Entity
    {
        System.ArgumentNullException.ThrowIfNull(btr);
        System.ArgumentNullException.ThrowIfNull(tr);

        var source = openErased ? btr.IncludingErased : btr;
        if (typeof(T) == typeof(Entity))
        {
            foreach (ObjectId id in source)
            {
                yield return (T)tr.GetObject(id, mode, openErased, forceOpenOnLockedLayers);
            }
        }
        else
        {
            var rxClass = RXObject.GetClass(typeof(T));
            foreach (ObjectId id in source)
            {
                if (id.ObjectClass.IsDerivedFrom(rxClass))
                {
                    yield return (T)tr.GetObject(id, mode, openErased, forceOpenOnLockedLayers);
                }
            }
        }
    }

    /// <summary>
    /// Synchronizes the attributes of all block references.
    /// </summary>
    /// <param name="target">Instance which the method applies.</param>
    /// <param name="tr">Transaction or OpenCloseTransaction to use.</param>
    /// <exception cref="System.ArgumentNullException">Thrown if <paramref name ="target"/> is null.</exception>
    /// <exception cref="System.ArgumentNullException">Thrown if <paramref name ="tr"/> is null.</exception>
    public static void SynchronizeAttributes(this BlockTableRecord target, Transaction tr)
    {
        System.ArgumentNullException.ThrowIfNull(target);
        System.ArgumentNullException.ThrowIfNull(tr);

        AttributeDefinition[] attDefs = target.GetObjects<AttributeDefinition>(tr).ToArray();
        foreach (BlockReference br in target.GetBlockReferenceIds(true, false).GetObjects<BlockReference>(tr, OpenMode.ForWrite))
        {
            br.ResetAttributes(tr, attDefs);
        }
        if (target.IsDynamicBlock)
        {
            target.UpdateAnonymousBlocks();
            foreach (BlockTableRecord btr in target.GetAnonymousBlockIds().GetObjects<BlockTableRecord>(tr))
            {
                attDefs = btr.GetObjects<AttributeDefinition>(tr).ToArray();
                foreach (BlockReference br in btr.GetBlockReferenceIds(true, false).GetObjects<BlockReference>(tr, OpenMode.ForWrite))
                {
                    br.ResetAttributes(tr, attDefs);
                }
            }
        }
    }

    /// <summary>
    /// Resets the attribute references keeping their values.
    /// </summary>
    /// <param name="target">Instance to which the method applies.</param>
    /// <param name="tr">Transaction or OpenCloseTransaction to use.</param>
    /// <param name="attDefs">Sequence of attribute definitions.</param>
    /// <exception cref="ArgumentNullException">Thrown if <paramref name ="target"/> is null.</exception>
    /// <exception cref="ArgumentNullException">Thrown if <paramref name ="tr"/> is null.</exception>
    /// <exception cref="ArgumentNullException">Thrown if <paramref name ="attDefs"/> is null.</exception>
    internal static void ResetAttributes(this BlockReference target, Transaction tr, IEnumerable<AttributeDefinition> attDefs)
    {
        ArgumentNullException.ThrowIfNull(target);
        ArgumentNullException.ThrowIfNull(tr);
        ArgumentNullException.ThrowIfNull(attDefs);

        var attValues = new Dictionary<string, string>();
        foreach (AttributeReference attRef in target.AttributeCollection.GetObjects(tr, OpenMode.ForWrite))
        {
            attValues.Add(attRef.Tag,
                attRef.IsMTextAttribute ? attRef.MTextAttribute.Contents : attRef.TextString);
            attRef.Erase();
        }
        foreach (AttributeDefinition attDef in attDefs)
        {
            var attRef = new AttributeReference();
            attRef.SetAttributeFromBlock(attDef, target.BlockTransform);
            if (attDef.Constant)
            {
                attRef.TextString = attDef.IsMTextAttributeDefinition ?
                    attDef.MTextAttributeDefinition.Contents :
                    attDef.TextString;
            }
            else if (attValues.TryGetValue(attDef.Tag, out string? value))
            {
                attRef.TextString = value;
            }
            target.AttributeCollection.AppendAttribute(attRef);
            tr.AddNewlyCreatedDBObject(attRef, true);
        }
    }

Referencing the library or adding this class to your project, you should be able to run the following one as many times as you like.

[CommandMethod("Test")]
public static void CommandMethod()
{
    var document = Application.DocumentManager.MdiActiveDocument;
    var database = document.Database;
    var editor = document.Editor;

    string blockName = "8x11Materiel";

    var blockFile = $@"{ResourcesFolderPath}\{blockName}.dwg";

    using var sourceDb = new Database(false, true);
    sourceDb.ReadDwgFile(blockFile, FileOpenMode.OpenForReadAndAllShare, false, null);
    database.Insert(blockName, sourceDb, false);

    SynchronizeBlockReferencesAttributes(database, blockName);

    editor.Regen(); // Refresh UI.
}

public static void SynchronizeBlockReferencesAttributes(Database db, string blockName)
{
    using Transaction transaction = db.TransactionManager.StartTransaction();

    // Get the block definition
    var blockTable = (BlockTable)transaction.GetObject(db.BlockTableId, OpenMode.ForRead);
    if (!blockTable.Has(blockName))
    {
        return;
    }
    var blockDefinition = (BlockTableRecord)transaction.GetObject(blockTable[blockName], OpenMode.ForWrite);

    blockDefinition.SynchronizeAttributes(transaction);

    transaction.Commit();
}

[bsaidiDG51]

This is what the method GetAttributesDefinition looked like:

public static IEnumerable<AttributeDefinition> GetAttributesDefinition(this BlockTableRecord blockTableRecord, Transaction transaction, OpenMode openMode = OpenMode.ForRead)
    {
        return blockTableRecord
            .Cast<ObjectId>()
            .Where(id => id.ObjectClass.Name == "AcDbAttributeDefinition")
            .Select(id => (AttributeDefinition)transaction.GetObject(id, openMode));
    }

The extension methods provided by @_gile have resolved my issue. This is how it looks like now:

public static IEnumerable<AttributeDefinition> GetAttributesDefinition(
    this BlockTableRecord blockTableRecord, 
    Transaction transaction, 
    OpenMode openMode = OpenMode.ForRead)
{
    return blockTableRecord.GetObjects<AttributeDefinition>(transaction, openMode);
}

Thanks to the both of you for your time.

[ActivistInvestor]

Just in case you're wondering why the original problem happened, it was because your code erases attribute references. The next time it runs it tries to open those erased attribute references. That happens because the AttributeCollection enumerates all attributes, including erased ones.

[ActivistInvestor]

Hi @_gile.

In your GetObjects<AttributeRefrerence>, you might also check to see if the BlockReference is a new object, in which case the AttributeCollection contains AttributeReferences, rather than ObjectIds:

public static IEnumerable<AttributeReference> GetAttributes(this BlockReference blkref, 
   Transaction tr, 
   OpenMode mode = OpenMode.ForRead,
   bool add = true)
{
   Assert.IsNotNullOrDisposed(blkref, nameof(blkref));
   Assert.IsNotNullOrDisposed(tr, nameof(tr));
   var objects = blkref.AttributeCollection.Cast<object>();
   object first = objects.FirstOrDefault();
   if(first != null)
   {
      if(first is AttributeReference)
      {
         foreach(AttributeReference attref in blkref.AttributeCollection)
         {
            if(add)
               tr.AddNewlyCreatedDBObject(attref, true);
            yield return attref;
         }
      }
      else
      {
         foreach(ObjectId id in blkref.AttributeCollection.Cast<ObjectId>()
               .Where(id=>!id.IsErased))
            yield return (AttributeReference)tr.GetObject(id, mode, false, false);
      }
   }
}