Lagen aanmaken en beheren in een AutoCAD C# add-in

Waarom lagen beheren vanuit code?

Wanneer je add-in automatisch objecten aanmaakt, wil je die op de juiste lagen plaatsen — niet op de actieve laag van de gebruiker, maar op gedefinieerde lagen met de juiste kleur, lijntype en lijndikte. Zo is de uitvoer altijd consistent, ongeacht hoe de tekening van de gebruiker is ingesteld.

Een laag aanmaken

Lagen zitten in de LayerTable van de database. Je opent die, controleert of de laag al bestaat, en maakt hem anders aan:

using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Colors;

/// <summary>
/// Maakt een laag aan als die nog niet bestaat, of retourneert de bestaande laag.
/// Geeft de ObjectId van de laag terug zodat je entiteiten erop kunt plaatsen.
/// </summary>
public static ObjectId ZorgVoorLaag(Database db, Transaction tr,
    string naam, short kleurIndex, string lijntype = "Continuous")
{
    // Haal de LayerTable op voor schrijven
    LayerTable lt = tr.GetObject(db.LayerTableId, OpenMode.ForRead) as LayerTable;

    // Als de laag al bestaat, retourneer haar ObjectId direct
    if (lt.Has(naam))
        return lt[naam];

    // Laag bestaat niet — open de table voor schrijven en maak haar aan
    lt.UpgradeOpen();

    LayerTableRecord laag = new LayerTableRecord();
    laag.Name      = naam;
    laag.Color     = Color.FromColorIndex(ColorMethod.ByAci, kleurIndex);
    laag.LineWeight = LineWeight.LineWeight025; // 0.25 mm standaard

    // Voeg de laag toe en registreer haar in de transactie
    ObjectId laagId = lt.Add(laag);
    tr.AddNewlyCreatedDBObject(laag, true);

    return laagId;
}

Lijntype koppelen aan een laag

Voordat je een lijntype aan een laag koppelt, moet het lijntype geladen zijn in de database. AutoCAD laadt standaard alleen "Continuous" — andere lijntypes (DASHED, CENTER, HIDDEN, …) moet je expliciet laden:

/// <summary>
/// Laadt een lijntype uit de standaard AutoCAD lijntype-bibliotheek (acad.lin).
/// Doet niets als het lijntype al geladen is.
/// </summary>
public static void LaadLijntype(Database db, string naam)
{
    LinetypeTable lt = db.TransactionManager.GetObject(
        db.LinetypeTableId, OpenMode.ForRead) as LinetypeTable;

    // Alleen laden als het nog niet in de database zit
    if (!lt.Has(naam))
    {
        // acad.lin bevat alle standaard AutoCAD-lijntypes
        db.LoadLineTypeFile(naam, "acad.lin");
    }
}

// Gebruik:
LaadLijntype(db, "DASHED");
LaadLijntype(db, "CENTER");

Daarna koppel je het lijntype aan de laag:

// Na het aanmaken van de laag, stel het lijntype in
LinetypeTable ltt = tr.GetObject(db.LinetypeTableId, OpenMode.ForRead) as LinetypeTable;
if (ltt.Has("DASHED"))
    laag.LinetypeObjectId = ltt["DASHED"];

Een object op een specifieke laag plaatsen

Je stelt de laag in via de LayerId property van de entiteit, vóór je hem toevoegt aan de ModelSpace:

[CommandMethod("KLEVERLAAGENTEST")]
public void LaagEnTest()
{
    Document doc = Application.DocumentManager.MdiActiveDocument;
    Database db  = doc.Database;

    using (Transaction tr = db.TransactionManager.StartTransaction())
    {
        // Laad benodigde lijntypes
        LaadLijntype(db, "DASHED");

        // Maak twee lagen aan
        ObjectId laagConstructie = ZorgVoorLaag(db, tr, "KC-CONSTRUCTIE", 5);  // blauw
        ObjectId laagMaatvoeringId = ZorgVoorLaag(db, tr, "KC-MAATVOERING", 3); // groen

        BlockTable bt = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
        BlockTableRecord ms = tr.GetObject(
            bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;

        // Lijn op de constructielaag
        Line lijn = new Line(new Point3d(0, 0, 0), new Point3d(150, 0, 0));
        lijn.LayerId = laagConstructie; // koppel aan laag
        ms.AppendEntity(lijn);
        tr.AddNewlyCreatedDBObject(lijn, true);

        // Maatlijn-placeholder op de maatvoeringslaag
        Line maat = new Line(new Point3d(0, -10, 0), new Point3d(150, -10, 0));
        maat.LayerId = laagMaatvoeringId;
        ms.AppendEntity(maat);
        tr.AddNewlyCreatedDBObject(maat, true);

        tr.Commit();
    }
}

Bestaande objecten verplaatsen naar een andere laag

Wil je bestaande entiteiten van laag wijzigen, dan open je ze voor schrijven en pas je de LayerId aan:

/// <summary>
/// Verplaatst alle entiteiten op "oudeLaag" naar "nieuweLaag".
/// </summary>
public static void WijzigLaag(Database db, Transaction tr,
    string oudeLaag, string nieuweLaag)
{
    LayerTable lt = tr.GetObject(db.LayerTableId, OpenMode.ForRead) as LayerTable;

    // Controleer of beide lagen bestaan
    if (!lt.Has(oudeLaag) || !lt.Has(nieuweLaag)) return;

    ObjectId nieuweLaagId = lt[nieuweLaag];

    // Loop door alle entiteiten in de ModelSpace
    BlockTable bt = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
    BlockTableRecord ms = tr.GetObject(
        bt[BlockTableRecord.ModelSpace], OpenMode.ForRead) as BlockTableRecord;

    foreach (ObjectId entId in ms)
    {
        Entity ent = tr.GetObject(entId, OpenMode.ForRead) as Entity;
        if (ent == null) continue;

        // Alleen verplaatsen als de entiteit op de oude laag zit
        if (ent.Layer == oudeLaag)
        {
            ent.UpgradeOpen(); // schakel over naar schrijfmodus
            ent.LayerId = nieuweLaagId;
        }
    }
}

Laageigenschappen achteraf aanpassen

Je kunt ook eigenschappen van bestaande lagen aanpassen — handig als je een standaard tekensjabloon wilt normaliseren:

[CommandMethod("KLEVERLAAGRESET")]
public void LaagReset()
{
    Database db = HostApplicationServices.WorkingDatabase;

    using (Transaction tr = db.TransactionManager.StartTransaction())
    {
        LayerTable lt = tr.GetObject(db.LayerTableId, OpenMode.ForRead) as LayerTable;

        // Loop door alle lagen
        foreach (ObjectId laagId in lt)
        {
            LayerTableRecord laag = tr.GetObject(laagId, OpenMode.ForRead) as LayerTableRecord;

            // Vergrendel lagen die beginnen met "REF-"
            if (laag.Name.StartsWith("REF-", StringComparison.OrdinalIgnoreCase))
            {
                laag.UpgradeOpen();
                laag.IsLocked = true; // vergrendel de laag
                laag.Color = Color.FromColorIndex(ColorMethod.ByAci, 8); // grijs
            }
        }

        tr.Commit();
    }
}

Handige laagoverzicht-hulpfunctie

/// <summary>
/// Schrijft een overzicht van alle lagen naar de AutoCAD commandoregel.
/// Nuttig tijdens development om te verifiëren welke lagen aanwezig zijn.
/// </summary>
[CommandMethod("KLEVERLAAGOVERZICHT")]
public void LaagOverzicht()
{
    Document doc = Application.DocumentManager.MdiActiveDocument;
    Database db  = doc.Database;
    Editor   ed  = doc.Editor;

    using (Transaction tr = db.TransactionManager.StartTransaction())
    {
        LayerTable lt = tr.GetObject(db.LayerTableId, OpenMode.ForRead) as LayerTable;

        ed.WriteMessage($"\n--- Lagen in tekening ({lt.Cast().Count()}) ---");

        foreach (ObjectId laagId in lt)
        {
            LayerTableRecord laag = tr.GetObject(laagId, OpenMode.ForRead) as LayerTableRecord;
            string status = laag.IsOff    ? "[UIT]"    :
                            laag.IsLocked ? "[VERGR]"  :
                            laag.IsFrozen ? "[BEVROREN]": "[AAN]";
            ed.WriteMessage($"\n  {laag.Name,-20} ACI:{laag.Color.ColorIndex,-4} {status}");
        }
    }
}

Conclusie

Door lagen programmatisch aan te maken en te beheren, geeft je add-in altijd een consistente tekenstructuur — ongeacht de startsituatie van de gebruiker. Gebruik de ZorgVoorLaag-hulpfunctie als bouwsteen in elk commando dat objecten aanmaakt.

Volgende post: hoe je gebruikersinvoer verwerkt en objecten laat selecteren in je add-in.

Why manage layers from code?

Manual layer management works fine for a single drawing, but when you process hundreds of drawings — or need to guarantee that company-standard layers always exist with the right settings — you need code. A C# add-in lets you enforce your layer standards automatically.

Reading the Layer Table

All layers in a drawing are stored in the LayerTable. You access it through the database, just like the BlockTable:

using Autodesk.AutoCAD.DatabaseServices;

Database db = HostApplicationServices.WorkingDatabase;

using (Transaction tr = db.TransactionManager.StartTransaction())
{
    // Open the LayerTable for reading
    LayerTable lt = tr.GetObject(db.LayerTableId, OpenMode.ForRead) as LayerTable;

    // Iterate over all layers in the drawing
    foreach (ObjectId layerId in lt)
    {
        LayerTableRecord layer = tr.GetObject(layerId, OpenMode.ForRead) as LayerTableRecord;
        // layer.Name, layer.Color, layer.IsOff, layer.IsFrozen, layer.IsLocked
    }

    tr.Commit();
}

Checking if a layer exists

bool LayerExists(Transaction tr, LayerTable lt, string layerName)
    => lt.Has(layerName);

Creating a new layer

using Autodesk.AutoCAD.Colors;

using (Transaction tr = db.TransactionManager.StartTransaction())
{
    LayerTable lt = tr.GetObject(db.LayerTableId, OpenMode.ForRead) as LayerTable;

    if (!lt.Has("CONSTRUCTION"))
    {
        // Open the table for writing so we can add a record
        lt.UpgradeOpen();

        using (LayerTableRecord newLayer = new LayerTableRecord())
        {
            newLayer.Name  = "CONSTRUCTION";
            newLayer.Color = Color.FromColorIndex(ColorMethod.ByAci, 8);  // ACI 8 = dark grey
            // newLayer.LinetypeObjectId = ...  // set linetype if needed

            lt.Add(newLayer);
            tr.AddNewlyCreatedDBObject(newLayer, true);
        }
    }

    tr.Commit();
}

Modifying an existing layer

using (Transaction tr = db.TransactionManager.StartTransaction())
{
    LayerTable lt = tr.GetObject(db.LayerTableId, OpenMode.ForRead) as LayerTable;

    if (lt.Has("CONSTRUCTION"))
    {
        // Open the layer record for writing
        LayerTableRecord layer = tr.GetObject(lt["CONSTRUCTION"], OpenMode.ForWrite) as LayerTableRecord;

        layer.Color    = Color.FromColorIndex(ColorMethod.ByAci, 3);  // Green
        layer.IsLocked = false;
        layer.IsOff    = false;   // Turn the layer on
        layer.IsFrozen = false;
    }

    tr.Commit();
}

Setting the current layer

using (Transaction tr = db.TransactionManager.StartTransaction())
{
    LayerTable lt = tr.GetObject(db.LayerTableId, OpenMode.ForRead) as LayerTable;

    if (lt.Has("CONSTRUCTION"))
    {
        // The current layer is stored on the database itself
        db.Clayer = lt["CONSTRUCTION"];
    }

    tr.Commit();
}

Assigning an entity to a layer

using (Transaction tr = db.TransactionManager.StartTransaction())
{
    LayerTable lt  = tr.GetObject(db.LayerTableId, OpenMode.ForRead) as LayerTable;
    BlockTable bt  = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
    BlockTableRecord ms = tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;

    using (Line line = new Line(new Point3d(0, 0, 0), new Point3d(100, 0, 0)))
    {
        // Assign to the CONSTRUCTION layer
        line.Layer = "CONSTRUCTION";
        ms.AppendEntity(line);
        tr.AddNewlyCreatedDBObject(line, true);
    }

    tr.Commit();
}

Practical example: enforce company layer standards

// Define your standard layers in a list
var standardLayers = new[]
{
    new { Name = "WALLS",       ColorIndex = (short)7,  Frozen = false },
    new { Name = "ANNOTATIONS", ColorIndex = (short)2,  Frozen = false },
    new { Name = "DIMENSIONS",  ColorIndex = (short)4,  Frozen = false },
    new { Name = "CONSTRUCTION",ColorIndex = (short)8,  Frozen = true  },
};

using (Transaction tr = db.TransactionManager.StartTransaction())
{
    LayerTable lt = tr.GetObject(db.LayerTableId, OpenMode.ForRead) as LayerTable;

    foreach (var def in standardLayers)
    {
        if (!lt.Has(def.Name))
        {
            lt.UpgradeOpen();
            using (LayerTableRecord rec = new LayerTableRecord())
            {
                rec.Name     = def.Name;
                rec.Color    = Color.FromColorIndex(ColorMethod.ByAci, def.ColorIndex);
                rec.IsFrozen = def.Frozen;
                lt.Add(rec);
                tr.AddNewlyCreatedDBObject(rec, true);
            }
        }
    }

    tr.Commit();
}

Run this command at the start of each drawing session to guarantee your standard layers are always present and correctly configured.