Aplicando uma operação a todas as entidades em um desenho do AutoCAD usando .NET

A grande questão do AutoCAD  .NET é que a maior patê das entidades são tratadas genericamente. Com isso existem algumas vantagens e algumas desvantagens.

A vantagem maior é que podemos também trata-los genericamente quando queremos usar uma função especifica de um determinado grupo.

Esta função generalista apaga todas as entidades em um desenho que atendem a uma condição de precisão. Desta forma este código apaga todas as entidades tipo “cruva” que tem seu comprimento zerado.

Eu uso um programa chamado PLS-CADD para plotação e elaboração de projetos de Linhas aéreas de transmissão. A saída do programa são documentos em DXF que precisam ser trabalhados em AutoCAD. Nesse documento de saída muitas informações devido a planificação do projeto são projetadas na planta ou no perfil através de uma linha de comprimento 0, uma questão organizacional do programa.

Esta função me ajuda a apagar todos os objetos dos desenhos.
Aqui está o código em C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;




namespace funcoesadicionais

{
    public static class extensoes
    {

        static int analisaentrada(this Database db, Func<Entity, bool> f)
        {
            int count = 0;
            using (var tr = db.TransactionManager.StartTransaction())
            {
                var bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
                foreach (ObjectId btrId in bt)
                {
                    var btr = (BlockTableRecord)tr.GetObject(btrId, OpenMode.ForRead);
                    foreach (ObjectId entId in btr)
                    {
                        var ent = tr.GetObject(entId, OpenMode.ForRead) as Entity;
                        if (ent != null && f(ent))
                        {
                            count++;
                        }
                    }
                }
                tr.Commit();
            }
            return count;
        }


        public static int apagarcondicional(
          this Database db, Func<Entity, bool> f, bool countOnly = false
        )
        {
            return
              db.analisaentrada(
                e =>
                {
                    if (f(e))
                    {
                        if (!countOnly)
                        {
                            e.UpgradeOpen();
                            e.Erase();
                            e.DowngradeOpen();
                        }
                        return true;
                    }
                    return false;
                }
              );
        }

        public static double Comprimento(this Curve curva)
        {
            return curva.GetDistanceAtParameter(curva.EndParam);
        }

        public static bool ComprimentoZero(this Curve curva)
        {
            bool resultado = curva.Comprimento() < Tolerance.Global.EqualPoint;
            return resultado;
        }
    }

    public class commds
    {
        [CommandMethod("APAGA_COMP_ZERADO")]
        public void APAGA_COMP_ZERADO()
        {
            var documento = Application.DocumentManager.MdiActiveDocument;
            if (documento == null)
                return;
            var db = documento.Database;
            var ed = documento.Editor;

            var count = db.apagarcondicional(
              e =>
              {
                  if (e is Curve)
                      return ((Curve)e).ComprimentoZero();
                  return false;
              }
            );

            ed.WriteMessage("\n{0} entidades apagadas com sucesso!", count);
        }

        [CommandMethod("APAGA_COMP_ZERADO_ALTERNATIVO")]
        public void APAGA_COMP_ZERADO_ALTERNATIVO()
        {
            var doc = Application.DocumentManager.MdiActiveDocument;
            if (doc == null)
                return;
            var db = doc.Database;
            var ed = doc.Editor;

            var count = db.apagarcondicional(
              e =>
              {
                  var cur = e as Curve;
                  if (cur != null && cur.ComprimentoZero())
                  {
                      e.UpgradeOpen();
                      e.Erase();
                      e.DowngradeOpen();

                      return true;
                  }
                  return false;
              }
            );

            ed.WriteMessage("\n{0} entidades apagadas com sucesso!", count);
        }
    }

}

Você pode comparar as implementações dos comandos funcionalmente de forma equivalente, APAGA_COMP_ZERADO e APAGA_COMP_ZERADO_ALTERNATIVO. Veja qual estilo você prefere.

Veja o vídeo do comando APAGA_COMP_ZERADO_ALTERNATIVO:

Projeto em Visual Studio 2019: Download