← Inbox

C3D-DIFF2403B · Diff LOT 10 vs R3 (read-only) error

Compare the two open 2403 drawings: layers, entity type counts, block inserts, Civil objects (cogo/alignments/surfaces/parcels). Report deltas.

C# payload

// READ-ONLY: compare the two open drawings (LOT 10 vs R3) across layers, entities by type,
// COGO points, blocks, and Civil objects. No writes.
using System;
using System.Linq;
using System.Collections.Generic;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Runtime;
using Autodesk.Civil.ApplicationServices;
using Autodesk.Civil.DatabaseServices;

var dm = Application.DocumentManager;

// summary of one drawing's contents
Dictionary<string,object> Summarize(Document doc)
{
    var db = doc.Database;
    var layers = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);
    var byType = new SortedDictionary<string,int>(StringComparer.OrdinalIgnoreCase);
    var blocks = new SortedDictionary<string,int>(StringComparer.OrdinalIgnoreCase);
    int cogo = 0, align = 0, surf = 0, parcels = 0, pipes = 0, msEntities = 0;

    using (doc.LockDocument())
    using (var tr = db.TransactionManager.StartTransaction())
    {
        var lt = (LayerTable)tr.GetObject(db.LayerTableId, OpenMode.ForRead);
        foreach (ObjectId id in lt)
            layers.Add(((LayerTableRecord)tr.GetObject(id, OpenMode.ForRead)).Name);

        var ms = (BlockTableRecord)tr.GetObject(
            SymbolUtilityServices.GetBlockModelSpaceId(db), OpenMode.ForRead);
        foreach (ObjectId id in ms)
        {
            msEntities++;
            var ent = tr.GetObject(id, OpenMode.ForRead);
            var tn = ent.GetType().Name;
            byType[tn] = byType.TryGetValue(tn, out var c) ? c + 1 : 1;
            if (ent is BlockReference br)
            {
                var btr = (BlockTableRecord)tr.GetObject(br.BlockTableRecord, OpenMode.ForRead);
                var bn = btr.Name;
                blocks[bn] = blocks.TryGetValue(bn, out var bc) ? bc + 1 : 1;
            }
        }

        try {
            var cdoc = CivilDocument.GetCivilDocument(db);
            cogo    = cdoc.CogoPoints.Count;
            align   = cdoc.GetAlignmentIds().Count;
            surf    = cdoc.GetSurfaceIds().Count;
            parcels = cdoc.GetSiteIds().Cast<ObjectId>()
                          .Sum(sid => ((Site)tr.GetObject(sid, OpenMode.ForRead)).GetParcelIds().Count);
        } catch (System.Exception ex) { Log($"  (civil read note: {ex.Message})"); }

        tr.Commit();
    }

    return new Dictionary<string,object> {
        {"file", doc.Name},
        {"layerCount", layers.Count},
        {"layers", layers},
        {"msEntities", msEntities},
        {"byType", byType},
        {"blocks", blocks},
        {"cogoPoints", cogo},
        {"alignments", align},
        {"surfaces", surf},
        {"parcels", parcels},
    };
}

var results = new List<Dictionary<string,object>>();
foreach (Document doc in dm)
{
    if (doc.Name.IndexOf("2403", StringComparison.OrdinalIgnoreCase) >= 0)
    {
        Log($"== {System.IO.Path.GetFileName(doc.Name)} ==");
        var s = Summarize(doc);
        results.Add(s);
        Log($"   layers={s["layerCount"]}  msEntities={s["msEntities"]}  cogo={s["cogoPoints"]}  align={s["alignments"]}  surfaces={s["surfaces"]}  parcels={s["parcels"]}");
    }
}

if (results.Count == 2)
{
    var a = results[0]; var b = results[1];
    string an = System.IO.Path.GetFileName((string)a["file"]);
    string bn = System.IO.Path.GetFileName((string)b["file"]);
    Log("");
    Log($"===== DIFF: {an}  vs  {bn} =====");

    // layers
    var la = (SortedSet<string>)a["layers"]; var lb = (SortedSet<string>)b["layers"];
    var onlyA = la.Except(lb, StringComparer.OrdinalIgnoreCase).ToList();
    var onlyB = lb.Except(la, StringComparer.OrdinalIgnoreCase).ToList();
    Log($"LAYERS: {an}={la.Count}, {bn}={lb.Count}");
    if (onlyA.Any()) Log($"  only in {an}: {string.Join(", ", onlyA)}");
    if (onlyB.Any()) Log($"  only in {bn}: {string.Join(", ", onlyB)}");
    if (!onlyA.Any() && !onlyB.Any()) Log("  layer sets identical");

    // entity type counts
    var ta = (SortedDictionary<string,int>)a["byType"]; var tb = (SortedDictionary<string,int>)b["byType"];
    var allTypes = ta.Keys.Union(tb.Keys, StringComparer.OrdinalIgnoreCase).OrderBy(x=>x);
    Log("ENTITY COUNTS BY TYPE (only where they differ):");
    foreach (var t in allTypes) {
        int ca = ta.TryGetValue(t, out var xa) ? xa : 0;
        int cb = tb.TryGetValue(t, out var xb) ? xb : 0;
        if (ca != cb) Log($"  {t}: {an}={ca}  {bn}={cb}  (Δ {cb-ca})");
    }

    // blocks
    var ba = (SortedDictionary<string,int>)a["blocks"]; var bb = (SortedDictionary<string,int>)b["blocks"];
    var allBlocks = ba.Keys.Union(bb.Keys, StringComparer.OrdinalIgnoreCase).OrderBy(x=>x);
    Log("BLOCK INSERT COUNTS (only where they differ):");
    bool anyBlk = false;
    foreach (var bl in allBlocks) {
        int ca = ba.TryGetValue(bl, out var xa) ? xa : 0;
        int cb = bb.TryGetValue(bl, out var xb) ? xb : 0;
        if (ca != cb) { Log($"  {bl}: {an}={ca}  {bn}={cb}"); anyBlk = true; }
    }
    if (!anyBlk) Log("  block insert counts identical");

    // civil tallies
    Log("CIVIL OBJECTS:");
    Log($"  cogoPoints: {an}={a["cogoPoints"]}  {bn}={b["cogoPoints"]}");
    Log($"  alignments: {an}={a["alignments"]}  {bn}={b["alignments"]}");
    Log($"  surfaces:   {an}={a["surfaces"]}  {bn}={b["surfaces"]}");
    Log($"  parcels:    {an}={a["parcels"]}  {bn}={b["parcels"]}");
}
else
{
    Log($"Expected 2 matching open drawings, found {results.Count}. Open both LOT 10 and R3.");
}

Result