AutoCAD DevBlog

Bridging the .NET Core and AutoCAD 2025: Exposing and Using COM Server Components with GetInterfaceObject

By Madhukar Moogala

In this blog post, we will explore how to expose COM server components in .NET Core and utilize them in AutoCAD using GetInterfaceObject.

Why Use COM in .NET Core?

COM (Component Object Model) provides a standardized way for software components to communicate, making it a popular tool for extending AutoCAD. For decades, it has been used to create external out-of-process applications and automate AutoCAD workflows.

While the .NET Framework offered seamless support for COM, achieving the same functionality in .NET Core or .NET 5+ requires additional effort. This blog post addresses how to migrate and expose COM components in the modern .NET environment.

We will reference Kean's old COM sample project, which works well in .NET Framework 4.8 but encounters issues in .NET 8.0. This post aims to bridge that gap.

As an example, we will create a COM server to calculate the value of Pi and use it within AutoCAD.

Step 1: Create a COM Server in .NET Core

Define Interfaces

To make AutoCAD compatible, we implement a fake IDispatch interface:

00020400-0000-0000-C000-000000000046 is special GUID of IDispatch

  
    [ComVisible(true)]
    [Guid("00020400-0000-0000-C000-000000000046")]
    [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
    public interface IDispatch
    {
        [DispId(1)]
        void GetTypeInfoCount(out int pctinfo);
        [DispId(2)]
        void GetTypeInfo(int iTInfo, int lcid, out IntPtr info);
        [DispId(3)]
        void GetIDsOfNames(ref Guid riid, ref IntPtr rgszNames, int cNames, int lcid, ref IntPtr rgDispId);
        [DispId(4)]
        void Invoke(int dispIdMember, ref Guid riid,
         int lcid, short wFlags, ref System.Runtime.InteropServices.ComTypes.DISPPARAMS pDispParams,
         out object pVarResult, ref System.Runtime.InteropServices.ComTypes.EXCEPINFO pExcepInfo,
         out int puArgErr);
    }

    [ComVisible(true)]
    [Guid("BA9AC84B-C7FC-41CF-8B2F-1764EB773D4B")]
    [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
    public interface IServer : IDispatch
    {
        [DispId(1)]
        double ComputePi();
    }
  

Implement the COM Server

The server calculates Pi using the Leibniz formula:

    
      [ComVisible(true)]
      [Guid("A8DAD545-A841-4EE4-B4DA-AAAC2FDDD305")]
      public class Server : IServer
      {
          double IServer.ComputePi()
          {
              double sum = 0.0;
              int sign = 1;
              for (int i = 0; i < 1024; ++i)
              {
                  sum += sign / (2.0 * i + 1.0);
                  sign *= -1;
              }
              return 4.0 * sum;
          }

          void IDispatch.GetIDsOfNames(ref Guid riid, ref IntPtr rgszNames, int cNames, int lcid, ref IntPtr rgDispId)
           => throw new NotImplementedException();
          void IDispatch.GetTypeInfo(int iTInfo, int lcid, out IntPtr info)
           => throw new NotImplementedException();
          void IDispatch.GetTypeInfoCount(out int pctinfo)
           => throw new NotImplementedException();
          void IDispatch.Invoke(int dispIdMember, ref Guid riid, int lcid,
          short wFlags, ref System.Runtime.InteropServices.ComTypes.DISPPARAMS pDispParams,
          out object pVarResult, ref System.Runtime.InteropServices.ComTypes.EXCEPINFO pExcepInfo,
          out int puArgErr) => throw new NotImplementedException();
      }
    
  

Step 2: Register the COM Server

Use regsvr32 to register the server *.comhost.dll. Ensure your assembly is visible to COM and has a unique GUID:

    
      [assembly: Guid("A8DAD545-A841-4EE4-B4DA-AAAC2FDDD305")]
      [assembly: TypeLibVersion(1, 0)] //Optional.
    
  

Step 3: Use the Server in AutoCAD

Implement the AutoCAD Plugin

The plugin retrieves the COM server object and uses it to compute Pi:

    
      [CommandMethod("RunDLL")]
      public void RunDLL()
      {
          var doc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
          if (doc == null)
              return;
      
          var editor = doc.Editor;
          dynamic acadObj = Autodesk.AutoCAD.ApplicationServices.Application.AcadApplication;
      
          if (acadObj != null)
          {
              try
              {
                  IServer serverObj = acadObj.GetInterfaceObject("COMServer.Server") as IServer;
                  if (serverObj != null)
                  {
                      double pi = serverObj.ComputePi();
                      editor.WriteMessage("\nPi: " + pi);
                  }
              }
              catch (Exception ex)
              {
                  editor.WriteMessage("\nError: " + ex.Message);
              }
          }
      }
    
  

Key Takeaways

1. Fake IDispatch Interface: Necessary for AutoCAD’s compatibility.

2. COM Server Registration: Ensures discoverability by AutoCAD.

Please refer GitHub repo for further details.

For more information, please refer to Microsoft article on COM Component in .NET core

Updating Associative Planar Surfaces Using AutoCAD's .NET API

By Madhukar Moogala

Associative surfaces in AutoCAD offer robust capabilities for maintaining dynamic links between geometric objects. Updating these surfaces programmatically requires careful handling of associated entities and profile curves. In this blog, we’ll explore how to automate the process of updating an associative planar surface with a new profile curve using AutoCAD .NET API.

Scenario Overview

The primary goal of this method is to update the profile curve of a planar surface while preserving its associative behavior. We assume the user selects a planar surface with a rectangular profile curve. If the surface is associative, the existing profile is replaced with a modified version.

Key Highlights

1. Surface Selection: Ensures the selected entity is a valid surface.
2. Associativity Check: Identifies whether the surface has an associated AssocActionBody.
3. Profile Extraction: Extracts edges from the associative surface and processes them as AutoCAD entities.
4. Profile Transformation: Demonstrates scaling the extracted profile using its centroid.
5. Input Path Update: Updates the planar surface with a transformed profile.

1. Surface Selection

The method starts by prompting the user to select a surface. It validates the selection to ensure the entity is a DBSurface.

    
      PromptEntityOptions surfaceSelectionPrompt = new PromptEntityOptions("\nSelect a surface: ");
      surfaceSelectionPrompt.SetRejectMessage("Must be a Surface!");
      surfaceSelectionPrompt.AddAllowedClass(typeof(DBSurface), exactMatch: false);
      PromptEntityResult selectionResult = documentEditor.GetEntity(surfaceSelectionPrompt);
    
  

2. Associativity Check

To determine if the surface is associative, the code checks for a valid AssocActionBody.

    
      var surfaceCreationActionId = selectedSurface.CreationActionBodyId;
      bool isSurfaceAssociative = false;
      
      if (surfaceCreationActionId != ObjectId.Null)
      {
          AssocActionBody associatedActionBody = transaction.GetObject(surfaceCreationActionId, OpenMode.ForRead) as AssocActionBody;
          isSurfaceAssociative = associatedActionBody != null;
      }      
    
  

3. Extracting and Transforming the Profile

If the surface is associative, its input paths are processed. The extracted edges are converted into entities, modified (e.g., scaled), and used to update the surface.

    
      planeActionBody.GetInputPaths(out EdgeRef[][][] edgeReferenceLayers);
      foreach (var edgeReferences in edgeReferenceLayers.SelectMany(layer => layer))
      {
          foreach (var edgeReference in edgeReferences)
          {
              Entity extractedEntity = edgeReference.CreateEntity();
              extractedEntity.ColorIndex = 1;
              extractedEntity.SetDatabaseDefaults();
              ents.Add(extractedEntity);
          }
      }
      if (ents[0] is Polyline pl)
      {
          var center = GetCentroid(pl);
          profile.TransformBy(Matrix3d.Scaling(10, center));
          planeActionBody.UpdateInputPath(0, new PathRef(new EdgeRef[] { new EdgeRef(profile) }));
      }
    
  

4. Evaluating the Associative Network

Once the profile is updated, AssocManager.EvaluateTopLevelNetwork ensures all dependencies are recalculated.

    
      AssocManager.EvaluateTopLevelNetwork(activeDatabase, null, 0);
    
  

Conclusion

This approach offers a structured way to programmatically update associative planar surfaces in AutoCAD, making it a valuable tool for design automation. Whether you’re scaling a profile curve, transforming it, or replacing it entirely, understanding the associative network and leveraging the .NET API unlocks a wealth of possibilities for automation.

Creating a Sample AutoCAD Plugin with .NET 8.0 and C++/CLI for AutoCAD 2025

By Madhukar Moogala

In this article, will walk through the development of a simple AutoCAD plugin using C++/CLI. The plugin will add a feature to draw circles dynamically, where users can specify the radius and the plugin will generate a random color for each circle.

We will break the plugin down into three major parts:

1. AutoCAD Database Helper Class
2. UI Form Implementation
3. ObjectARX Entry Point

Part 1: AutoCAD Database Helper Class

In AutoCAD, entities such as circles, lines, and other objects are stored in the AutoCAD database. The AcDbHelper class in our plugin facilitates the creation and manipulation of AutoCAD entities.

Smart Pointer for AutoCAD Database Objects

We start by creating a unique_db_ptr template class to manage AutoCAD objects with a smart pointer. This ensures that AutoCAD objects are correctly cleaned up after use.

      
        template  struct unique_db_ptr : public std::unique_ptr
          {
              unique_db_ptr(T* t) : std::unique_ptr(t, closeOrDeleteDbObj) { }
          
              static unique_db_ptr create()
              {
                  T* newObj = new T();
                  return unique_db_ptr(newObj);
              }
          
              // Helper function for smart pointer cleanup
              static void closeOrDeleteDbObj(AcDbObject* pObj)
              {
                  if (pObj->objectId().isNull())
                      delete pObj;
                  else
                      pObj->close();
              }
          };
          
      
    

Adding Entities to the Database

We also define a method to add entities like circles to AutoCAD's model space, ensuring they are correctly appended to the database.

    
    static bool addToDb(AcDbEntity* pEnt, AcDbDatabase* pDb = nullptr)
    {
    if (!pDb)
        pDb = acdbHostApplicationServices()->workingDatabase();

    unique_db_ptr ent(pEnt);
    AcDbBlockTable* pBt;
    if (Acad::eOk != pDb->getBlockTable(pBt, AcDb::kForRead))
        return false;

    unique_db_ptr bt(pBt);
    AcDbBlockTableRecord* pMs;
    if (Acad::eOk != pBt->getAt(ACDB_MODEL_SPACE, pMs, AcDb::kForWrite))
        return false;

    return Acad::eOk == unique_db_ptr(pMs)->appendAcDbEntity(ent.get());
    }
    
  

Creating and Adding Circles

The createCircle method creates a circle with a specified radius and color index, then adds it to the database:

  
    static bool createCircle(const AcGePoint3d& center, double radius, int colorIndex = 1)
      {
          auto circlePtr = unique_db_ptr::create();
          if (!circlePtr)
              return false;

          AcDbCircle* circle = circlePtr.get();
          circle->setDatabaseDefaults();
          circle->setRadius(radius);
          circle->setColorIndex(colorIndex);
          circle->setCenter(center);
          return addToDb(circle);
      }
  
  

Part 2: UI Form Implementation

Now, let’s move on to creating the user interface (UI) that interacts with the AutoCAD database. We’ll use Windows Forms in C++/CLI for this purpose.

MainForm Class

The MainForm class represents the UI, containing a button to draw a circle and a numeric input for the circle radius. It uses a task-based asynchronous method to perform the drawing operation on the main AutoCAD thread.

    
      public ref class MainForm : public Form
      {
      private:
          Button^ drawButton;
          NumericUpDown^ radiusInput;
          Label^ radiusLabel;

          void InitializeComponent()
          {
              //adding controls to the form and initialising properties
          }

          Task^ DrawCircleAsync(System::Object^ data)
          {
              //draw the circle
          }

          void DrawButton_Click(System::Object^ sender, System::EventArgs^ e)
          {
              // Handle click event
              auto dm = Autodesk::AutoCAD::ApplicationServices::Core::Application::DocumentManager;

              // Create the delegate with the correct syntax
              auto callback = gcnew Func(this, &MainForm::DrawCircleAsync);
             
              // Execute the callback in the command context
              auto task = dm->ExecuteInCommandContextAsync(callback, nullptr);
               task->GetResult();
              // Enable the button
               drawButton->Enabled = true;
              // Set focus to the drawing area and zoom extents
               AcadUtils::Utils::SetFocusToDwgView();
               AcadUtils::Utils::CancelAndRunCmds("_.zoom\n_extents\n");
          }

      public:
          MainForm()
          {
              InitializeComponent();
          }
      };
    
  

ExecuteInCommandContextAsync Method

In this code, the ExecuteInCommandContextAsync method is used to execute a callback (in this case, the DrawCircleAsync method) within AutoCAD's command context. The primary reason for using this API is to ensure that any interactions with AutoCAD, especially those that modify the drawing or perform operations on the AutoCAD database, are executed on the correct thread, which is the AutoCAD main thread.

Why Use ExecuteInCommandContextAsync?

AutoCAD, being a single-threaded application, has strict rules about how commands and modifications to the AutoCAD database should be performed. Interacting with AutoCAD from another thread, such as a UI thread, can cause problems because it bypasses AutoCAD's synchronization mechanisms, leading to potential crashes, invalid operations, or unexpected behavior.

SynchronizationContext Issue

When you display a WinForm dialog (like MainForm in your code), it restores the 'previous' SynchronizationContext, which in this case is the default context. This default context attempts to execute continuations using the thread pool, not the main AutoCAD thread. Since AutoCAD requires that commands (such as modifying the database or interacting with the drawing) be run on its main thread, executing on a background thread (via the thread pool) can cause synchronization issues.

AutoCAD doesn't like this because it expects all UI operations and database modifications to occur on the main AutoCAD thread. If you try to execute these operations on a different thread (e.g., using the thread pool), AutoCAD's internal threading model will not handle it correctly.

How ExecuteInCommandContextAsync Solves This

By using ExecuteInCommandContextAsync, the callback (i.e., the DrawCircleAsync method) is explicitly executed within AutoCAD's command context. This method ensures that the operation is correctly scheduled on the AutoCAD thread, which means:

1. Correct Threading: It guarantees that the AutoCAD API calls are made on the main AutoCAD thread, which is crucial for thread safety.
2. Synchronization Context: It sets up the correct synchronization context for the operation, so any continuation (like UI updates or database operations) that happens after this method call will respect AutoCAD's threading model and ensure that UI updates (like enabling buttons) are done on the UI thread without causing conflicts.
3. Asynchronous Execution: It allows the asynchronous execution of AutoCAD commands without blocking the UI thread or causing AutoCAD to freeze while waiting for the operation to complete. The GetResult() method ensures that the UI thread waits for the task to finish before proceeding.

Part 3: ObjectARX Entry Point

The CArxNetCoreApp class represents the entry point of our AutoCAD plugin. It registers the application and launches the UI dialog.

    
      class CArxNetCoreApp : public AcRxArxApp
      {
      public:
          virtual AcRx::AppRetCode On_kInitAppMsg(void* pkt) { 
            return AcRxArxApp::On_kInitAppMsg(pkt); }
          virtual AcRx::AppRetCode On_kUnloadAppMsg(void* pkt) { 
            return AcRxArxApp::On_kUnloadAppMsg(pkt); }
          virtual void RegisterServerComponents() {}

          static void MADGUIToolLaunch()
          {
              try
              {
                  auto form = gcnew UIForms::MainForm();
                  Autodesk::AutoCAD::ApplicationServices::Application::ShowModelessDialog(form);
              }
              catch (System::Exception^ ex)
              {
                  acutPrintf(L"\nException occurred: %s", ex->Message);
              }
          }
      };
    
  

Conclusion

This plugin demonstrates how to integrate AutoCAD with C++/CLI, offering a simple yet powerful tool to interact with AutoCAD's database, create entities, and provide a user-friendly interface for drawing circles. The use of smart pointers, task-based asynchronous methods, and Windows Forms for UI design highlights the flexibility and power of combining C++/CLI with AutoCAD's ObjectARX SDK.

By following the steps outlined in this tutorial, you can build and expand upon this basic plugin to add more features and functionality to AutoCAD.

View on GitHub

Safeguarding Database Pointers with AcDbDatabase’s New Runtime ID API

By Madhukar Moogala

In Autodesk software, developers sometimes face an issue where a memory address, specifically an AcDbDatabase pointer, may get reused. If a database (DB) is deleted and a new one is created at the same memory location, how can we distinguish between the two instances?

This question led us to introduce a new API—runtimeId.

Why the Change?

Our team noticed a pattern in crash reports related to stale AcDbDatabase pointers. Often, these issues stemmed from cached pointers that were no longer valid but hadn’t been refreshed. To help clients validate their pointers, we recommended using acdbActiveDatabaseArray() to search for active database pointers.

While this method allowed clients to identify active pointers, it came with two limitations:

1. Performance Overhead: As the number of open databases increases, searching through an array can introduce delays.
2. Ambiguity of Validity: Even if a pointer is valid, it doesn’t guarantee it points to the originally intended database instance.

This is where the runtimeId API comes in.

New API Methods for Safer Database Management

The new runtime ID API allows clients to confirm both the validity and uniqueness of a database pointer:

• AcDbDatabase::runtimeId(): Retrieves a unique runtime ID for the current database instance, distinguishing it from any previous instance.
• AcDbDatabase::dbIdFromPtr(): A static method that returns the runtime ID from a pointer, if valid.
• AcDbDatabase::dbPtrFromId(): A static method that returns the database pointer from an ID, if valid.

By using these methods, developers can cache the runtime ID for long-term usage, ensuring a reliable reference to the database, even if a pointer address is reused.

Future-Proofing with Runtime ID

This approach enables efficient, reliable database pointer management and protects against the issues caused by re-used memory locations. By using runtime IDs, developers can avoid stale pointers and maintain database integrity with minimal performance impact.

        #if DEBUG
    [DllImport("acpal.dll", CallingConvention = CallingConvention.Cdecl,
               CharSet = CharSet.Ansi, EntryPoint = "acutSetAssertDia")]
    static extern bool acutSetAssertDia(bool bSetDia);
      #endif
 

    [CommandMethod("TestRunTimeId")]
    public static void TestRunTimeId()
    {
        var doc = Application.DocumentManager.MdiActiveDocument;
        if (doc == null) return;

        var ed = doc.Editor;

        var firstDb = new Database(true, true);
        var transDb = new Database(true, true);

        // Validate layer table ID
        var id = firstDb.LayerTableId;
        if (!id.IsValid)
        {
            ed.WriteMessage("\nLayer ID is not valid.");
        }
        if (!id.IsWellBehaved)
        {
            ed.WriteMessage("\nLayer ID is not well-behaved.");
        }

        // Attempt to access object in the transaction
        using (Transaction t = transDb.TransactionManager.StartTransaction())
        {
            var obj = t.GetObject(id, OpenMode.ForRead, false);
            if (obj == null)
            {
                ed.WriteMessage("\nCannot open the layer table.");
            }
        }

        // Retrieve and compare runtime IDs
        long rid1 = firstDb.RuntimeId();
        if (rid1 <= 0)
        {
            ed.WriteMessage("\nRuntimeId < 0!");
        }
        if (rid1 != Database.IdFromDb(firstDb))
        {
            ed.WriteMessage("\nDatabase ID from pointer does not match runtime ID!");
        }

        long rid2 = transDb.RuntimeId();
        if (rid2 <= 0)
        {
            ed.WriteMessage("\nRuntimeId < 0!");
        }
        if (rid2 != Database.IdFromDb(transDb))
        {
            ed.WriteMessage("\nTransaction DB ID from pointer does not match runtime ID!");
        }
        if (Database.DbFromId(rid2) != transDb)
        {
            ed.WriteMessage("\nDbPtrFromId returned an incorrect pointer for transDb!");
        }
        if (rid1 == rid2)
        {
            ed.WriteMessage("\nDB and transDb have identical runtime IDs!");
        }

        // Validate null/zero scenarios
        if (Database.DbFromId(0) != null)
        {
            ed.WriteMessage("\nDbFromId(0) returned non-null!");
        }
        if (Database.IdFromDb(null) != 0)
        {
            ed.WriteMessage("\nIdFromDb(null) returned non-zero!");
        }

        // Delete firstDb and check pointer validity
        firstDb.Dispose();
        if (Database.DbFromId(rid1) != null)
        {
            ed.WriteMessage("\nDeleted DB's ID returned a non-null pointer!");
        }
        if (Database.IdFromDb(firstDb) != 0)
        {
            ed.WriteMessage("\nDeleted DB's stale pointer returned non-zero ID!");
        }

        // Check the validity and behavior of stale layer ID
        if (id.IsValid)
        {
            ed.WriteMessage("\nStale layer ID is still valid?");
        }
        if (!id.IsWellBehaved)
        {
            ed.WriteMessage("\nStale layer ID is not well-behaved?");
        }

        // Start a transaction to test stale ID access gracefully
        using (Transaction t = transDb.TransactionManager.StartTransaction())
        {
            acutSetAssertDia(false); // Disable asserts for this test
            try
            {
                var obj = t.GetObject(id, OpenMode.ForRead, false);
                if (obj != null)
                {
                    ed.WriteMessage("\nAccess to stale ID succeeded?");
                }
            }
            catch (Autodesk.AutoCAD.Runtime.Exception e)
            {

                ed.WriteMessage($"\nUnexpected GetObject() exception: {e.Message}");
            }
            acutSetAssertDia(true); // Re-enable asserts
        }

        // Clean up transDb
        transDb.Dispose();
        if (Database.DbFromId(rid2) != null)
        {
            ed.WriteMessage("\nDeleted transDb's ID returned a non-null pointer!");
        }
        if (Database.IdFromDb(transDb) != 0)
        {
            ed.WriteMessage("\nDeleted transDb's stale pointer returned non-zero ID!");
        }
    }
       

Working with UCS and Ordinate Dimensions in AutoCAD using .NET API

By Madhukar Moogala

In the world of CAD (Computer-Aided Design), precision is key.

AutoCAD provides developers with powerful tools to manipulate objects and dimensions programmatically. One of the most critical concepts in AutoCAD development is the use of coordinate systems. This blog post will guide you through the process of working with the User Coordinate System (UCS) and creating ordinate dimensions using the AutoCAD .NET API.

Understanding Coordinate Systems in AutoCAD

AutoCAD operates using two main coordinate systems: the World Coordinate System (WCS) and the User Coordinate System (UCS).

• World Coordinate System (WCS): This is the fixed global coordinate system in AutoCAD. All points, lines, and objects are placed relative to the WCS by default.

• User Coordinate System (UCS): UCS allows you to define a custom coordinate system, aligning objects, views, or dimensions to any plane or orientation in 3D space. It’s particularly useful when working with objects at odd angles or creating dimensions aligned to specific geometric features.

By transforming points and objects to UCS, you can create more flexible and intuitive designs, and AutoCAD’s .NET API provides all the necessary tools to do this programmatically.

Exploring Ordinate Dimensions

Ordinate dimensions are used to measure the X or Y coordinates of a point in a drawing. Unlike linear dimensions, ordinate dimensions don’t rely on start and end points. Instead, they measure the position relative to a predefined origin—making them perfect for designs that require a high degree of coordinate accuracy, such as mechanical parts or assembly plans.

AutoCAD’s .NET API allows developers to create and customize ordinate dimensions with precision, ensuring that the correct values are displayed in the right locations.

---

Code Walkthrough: Creating and Manipulating UCS and Ordinate Dimensions

Now that we understand the concepts, let's dive into some code.

1. Setting Up the UCS

In AutoCAD, we can define a custom UCS and apply it to a viewport. This allows for precise control over the orientation of the drawing, aligning it with the real-world axes or a specific plane.

Here’s how we create a UCS programmatically and apply it to a viewport:

    
    public static void TestDimOrdinate()
    {
    var doc = Application.DocumentManager.MdiActiveDocument;
    var db = doc.Database;
    var ed = doc.Editor;

    using (var tr = db.TransactionManager.StartTransaction())
    {
        // Access the BlockTable and UCS Table
        var bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
        var ucsTbl = (UcsTable)tr.GetObject(db.UcsTableId, OpenMode.ForRead);
        
        UcsTableRecord ucstr;
        if (!ucsTbl.Has("TestUcs"))
        {
            ucstr = new UcsTableRecord { Name = "TestUcs" };
            ucsTbl.UpgradeOpen();
            ucsTbl.Add(ucstr);
            tr.AddNewlyCreatedDBObject(ucstr, true);
        }
        else
        {
            ucstr = (UcsTableRecord)tr.GetObject(ucsTbl["TestUcs"], OpenMode.ForWrite);
        }

        // Define the UCS origin and axes
        ucstr.Origin = Point3d.Origin;
        ucstr.XAxis = new Vector3d(1, 1, 0);
        ucstr.YAxis = new Vector3d(-1, 1, 0);

        // Apply UCS to the active viewport
        var vptr = (ViewportTableRecord)tr.GetObject(ed.ActiveViewportId, OpenMode.ForWrite);
        vptr.SetUcs(ucstr.ObjectId);
        doc.Editor.UpdateTiledViewportsFromDatabase();
        
        tr.Commit();
    }
  }
    
  

Here, we create a new UCS named "TestUcs", define its origin, X-axis, and Y-axis, and apply it to the active viewport. This UCS is then used to place ordinate dimensions based on the user’s input points.

2. Handling User Input and Transforming Points

To place ordinate dimensions, we first need to gather two points from the user and transform them from the WCS into the current UCS:

    
    PromptPointOptions pPtOpts = new PromptPointOptions("");
    Point3d[] point3Ds = new Point3d[2];

    for (int i = 0; i < 2; i++)
    {
        pPtOpts.Message = $"\nEnter point {i + 1}: ";
        var pPtRes = doc.Editor.GetPoint(pPtOpts);

        if (pPtRes.Status != PromptStatus.OK)
        {
            doc.Editor.WriteMessage("\nPoint input was canceled or invalid.");
            break;
        }

        point3Ds[i] = pPtRes.Value;
    }

    // Transform points to UCS
    Matrix3d activeUCS = ed.CurrentUserCoordinateSystem;
    Point3d ucsDp = point3Ds[0].TransformBy(activeUCS);
    Point3d ucsLp = point3Ds[1].TransformBy(activeUCS);
    
  

This code collects two points from the user, transforming them from WCS to UCS using TransformBy().

3. Fixing Angles and Floating-Point Precision

When dealing with floating-point operations, tiny precision errors can lead to discrepancies in different systems. To address this, we normalize angles to ensure they fall within the [0, 2π] range and fix close-to-zero negative values:

    
      const double ANGLE_EPSILON = 1E-15;

      public static bool IsNearZero(double num)
      {
          return num < ANGLE_EPSILON && num > -ANGLE_EPSILON;
      }

      public static double FixAngle(double angle)
      {
          const double TWOPI = 2 * Math.PI;
          double retang = angle / TWOPI;
          retang = (retang - (int)retang) * TWOPI;

          if (retang < 0 && IsNearZero(retang))
          {
              retang = 0.0;
          }

          if (retang < 0.0) retang += TWOPI;
          if (retang >= TWOPI) retang -= TWOPI;

          return retang;
      }
    
  

Here, we ensure angles like -2E-16 are unified to zero, addressing differences in floating-point precision across different architectures.

Though AutoCAD is designed for x64-based processor architectures only as of today, sake of brevity considered other architectures like ARM

4. Creating Ordinate Dimensions

Finally, we can create ordinate dimensions based on the transformed points:

    
      double rotation = UserToLocalAngle(activeUCS.CoordinateSystem3d.Zaxis, activeUCS.CoordinateSystem3d.Xaxis);

      OrdinateDimension ordDim = new OrdinateDimension
      {
          DefiningPoint = ucsDp,
          LeaderEndPoint = ucsLp,
          Normal = activeUCS.CoordinateSystem3d.Xaxis.CrossProduct(activeUCS.CoordinateSystem3d.Yaxis),
          UsingXAxis = false,
          DimensionStyle = db.Dimstyle,
          HorizontalRotation = -rotation
      };

      btr.AppendEntity(ordDim);
      tr.AddNewlyCreatedDBObject(ordDim, true);

    
  

This snippet defines an ordinate dimension using the points transformed into UCS, sets its dimension style, and applies the necessary rotation to ensure the dimension aligns correctly with the current UCS.

Note: we are setting a rotation angle to the dimension, so the Ordinate Dimension is correctly aligned with UCS

This is the angle from the dimension's positive horizontal axis (which is the X axis of the UCS in effect when the dimension was created) to the X axis of the dimension's OCS (as defined by the dimension's normal vector and the arbitrary axis algorithm). Positive angles are counterclockwise when looking down the OCS Z axis towards the OCS origin. The dimension's positive horizontal axis direction is used as the default left-to-right direction for the dimension text.

Common Pitfalls and Best Practices

1. Handling Floating-Point Precision:

   • Small errors can accumulate when performing geometric calculations. Always normalize your values and use an epsilon threshold for comparing floating-point numbers.

2. Working with UCS:

   • Always ensure you’re transforming points to the correct coordinate system before performing operations. This avoids misalignment issues, especially when working in 3D space.

3. Testing on Different Architectures *:

   • Differences in floating-point precision between architectures (Intel vs ARM) can affect calculations. Normalize close-to-zero values to avoid discrepancies.

---

Conclusion

In this blog, we’ve explored how to create and manipulate UCS in AutoCAD using the .NET API, gathering user input, fixing floating-point precision issues, and creating ordinate dimensions. Understanding these concepts allows developers to create more complex and accurate drawings programmatically, especially when precision is essential.

Experiment with the provided code, and see how you can enhance your AutoCAD projects by harnessing the power of the UCS and the .NET API. Happy coding!

AutoCAD 2025 : Marshal.GetActiveObject .NET Core

By Madhukar Moogala

The GetActiveObject method is deprecated in .NET 8, specifically starting from .NET Core 3.0. The Marshal.GetActiveObject() API is a simple wrapper over the Running Object Table (ROT) and relies on folllwing Win32 APIs that can easily be called via P/Invoke.

• CLSIDFromProgIDEx
• GetActiveObject

An example of how to manually communicate with the ROT can be found at this GitHub repository. It is unlikely that Microsoft will bring this API back.

Let's write a our own method GetActiveObject

    
      [DllImport("ole32")]
      private static extern int CLSIDFromProgIDEx(
        [MarshalAs(UnmanagedType.LPWStr)] string lpszProgID,
        out Guid lpclsid);
      [DllImport("oleaut32")]
      private static extern int GetActiveObject(
        [MarshalAs(UnmanagedType.LPStruct)] Guid rclsid,
        IntPtr pvReserved,
        [MarshalAs(UnmanagedType.IUnknown)] out object ppunk);

      public static object? GetActiveObject(string progId,
                                           bool throwOnError = false)
      {
      if (progId == null)
          throw new ArgumentNullException(nameof(progId));

      var hr = CLSIDFromProgIDEx(progId, out var clsid);
      if (hr < 0)
      {
          if (throwOnError)
              Marshal.ThrowExceptionForHR(hr);

          return null;
      }
      hr = GetActiveObject(clsid, IntPtr.Zero, out var obj);
      if (hr < 0)
      {
          if (throwOnError)
              Marshal.ThrowExceptionForHR(hr);

          return null;
      }
      return obj;
      }
    
    

Multi-targeting AutoCAD .NET Plugin for .NET 4.8 and .NET 8.0

By Madhukar Moogala

Recently, we received a query from an ADN partner on how to organize code to target multiple frameworks, such as .NET 4.x and .NET 8.0.

Let's take an ARX SDK sample project, EllipseJig.

EllipseJig is a simple .NET project that demonstrates the use of Jig APIs to create ellipses. The project is available in the ObjectARX SDK samples

Here is the project structure

  
    <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <AssemblyName>JigSample</AssemblyName>
        <OutputType>Library</OutputType>
        <RootNamespace>JigSample</RootNamespace>
        <TargetFramework>net8.0-windows</TargetFramework>
        <GenerateAssemblyInfo>False</GenerateAssemblyInfo>
        <Platforms>x64</Platforms>
        <Configurations>ACAD2024;ACAD2025</Configurations>
        <BaseOutputPath>bin</BaseOutputPath>
    </PropertyGroup>
    <PropertyGroup Condition="'$(Configuration)' == 'ACAD2025'">
        <TargetFramework>net8.0-windows</TargetFramework>
        <!-- uncomment to use Forms or WPF-->
        <!--<UseWindowsForms>true</UseWindowsForms>
      <UseWPF>true</UseWPF>-->
        <AssemblySearchPaths>D:\ArxSdks\Arx2025\inc\;$(AssemblySearchPaths)</AssemblySearchPaths>
    </PropertyGroup>
    <PropertyGroup Condition="'$(Configuration)' == 'ACAD2024'">
        <TargetFramework>net48</TargetFramework>
        <AssemblySearchPaths>D:\ArxSdks\Arx2024\inc\;$(AssemblySearchPaths)</AssemblySearchPaths>
    </PropertyGroup>
    <ItemGroup Condition="'$(Configuration)' == 'ACAD2025'">
        <FrameworkReference Include="Microsoft.WindowsDesktop.App"/>
    </ItemGroup>
    <ItemGroup>
        <Reference Include="AcDbMgd">
            <Private>False</Private>
        </Reference>
        <Reference Include="acmgd">
            <Private>False</Private>
        </Reference>
        <Reference Include="accoremgd">
            <Private>False</Private>
        </Reference>
    </ItemGroup>
</Project>
  
  

Github Project : Ellipsejig

Note:

We encourage you to use Git branching to organize and maintain releases instead of organizing projects to target multiple frameworks. This is the same approach we adopt with the AutoCAD source code, which has billions of lines of code.

In the image below, our main branch is always the latest and newest state and content.

When it's time to switch to a new release, we branch "main" into "release2025." After that, "main" will become "2026," and so on.

So, if your main branch is currently supporting AutoCAD 2024, you would branch this off into "release2024" and then change "main" to support AutoCAD 2025.

For example, please find the Github project : ManagedCircle

There are two branches:

• master - which is the current release 2025,
• another branch for AutoCAD 2024 (.NET F4x)

If I have to roll out a fix to AutoCAD 2024, I will simply switch to that branch and work on it.

AutoCAD 2025: Update Your PackageContents.xml with RuntimeRequirements

By Madhukar Moogala

If you are using PlugIn-Autoloader mechanism to install custom applications, this important update is for you

With the release of AutoCAD 2025, Autoloader engine checks for RuntimeRequirements for applications. In other words, you need to specify the series bounds for your application if the ComponentEntry \ AppType is .NET to load in AutoCAD 2025.

RuntimeRequirements has two attributes which defines supportablity of your application component on AutoCAD

The following description holds true for any other application but not for .NET plugins.

RuntimeRequirements Attributes

Attribute	Description
SeriesMin	Defines the minimum product release number that the set of components supports.The value can be a major version number (R24) or a specific version (R24.1). The version number can be found in the Windows Registry or obtained with the ACADVER system variable in AutoCAD-based products.If this attribute and SeriesMaxare not specified, it is assumed all components are compatible with all product releases. If you omit this value, any version before that specified by the SeriesMaxattribute is allowed.
SeriesMax	Defines the maximum product release number that the set of components supports.If you omit this value, any version after that specified by the SeriesMin attribute is allowed.

What Changed?

If the SeriesMax is not set for a particular component in the bundle PackageContents.xml (via the RuntimeRequirements element) the Autoloader assumes it is a compatible component and loads it. However, since the API breaks because of the .NET upgrade, the app may crash while loading.

So, it is important to specify the SeriesMax attribute in the RuntimeRequirements element.

Here is the sample code PackageContents.xml to specify the series bounds for your .NET based applications targeting AutoCAD 2025

EDIT:

Thanks to Nedeljko Sovljanski it was plain oversight to place RuntimeRequirements at incorrect scope.

      
    <?xml version="1.0" encoding="UTF-8"?>
    <ApplicationPackage SchemaVersion="1.0" Name="HelloWorld" 
    AppVersion="2024.1.0" Description="A basic HelloWorld application"
     Author="Madhukar Moogala" ProductCode="90bcc406-78d2-4667-bef8-12c02e1ab25b">
       <CompanyDetails Name="APS" Url="" Email="" />
       <Components>
          <ComponentEntry AppName="HelloWorld" 
          ModuleName="HelloWorld.dll" 
          AppDescription="A simple hello" 
          AppType=".Net" 
          LoadOnAutoCADStartup="True">
             <RuntimeRequirements OS="Win64" SeriesMin="R20.0" SeriesMax="R24.3" />
             <Commands GroupName="HelloMGD">
                <Command Local="HELLO" Global="HELLO" />
             </Commands>
          </ComponentEntry>
          <ComponentEntry AppName="HelloWorld" 
          ModuleName="HelloWorld_NET8.0.dll" 
          AppDescription="A simple hello" 
          AppType=".Net" 
          LoadOnAutoCADStartup="True">
             <RuntimeRequirements OS="Win64" SeriesMin="R25.0" SeriesMax="R25.0" />
             <Commands GroupName="HelloMGD">
                <Command Local="HELLO" Global="HELLO" />
             </Commands>
          </ComponentEntry>
       </Components>
    </ApplicationPackage>    
    
    

Upgrading C++/CLI Wrappers for Custom Entities to .NET 8.0

By Madhukar Moogala

AutoCAD 2025 started supporting .NET 8.0 platform, if you have managed wrapper or interop API for custom entities, you need to upgrade them from NET 4.x to NET 8.0

Upgrading managed wrappers is three fold process

First, you need to upgrade arx or dbx project (*.vcxproj) to target new SDK version

Second, you need to upgrade the wrapper project (C++\CLI) to NET 8.0

Third, you need to upgrade the client side plugin project from NET 4x to NET 8.0

Here is the step by step guide to upgrade the managed wrapper project from NET 4.x to NET 8.0

1. Update the .vcxproj File:

   • Replace <CLRSupport>true</CLRSupport> properties with <CLRSupport>NetCore</CLRSupport>.
   • Replace <TargetFrameworkVersion> properties with <TargetFramework>net8.0</TargetFramework>.

2. Remove .NET Framework References:

   • Remove any references to System, System.Core,System.Data, System.Windows.Forms, and System.Xml from your project.

3. Update API Usage:

   • Review your .cpp files and update any APIs that are unavailable in .NET.

4. WPF and Windows Forms Usage:

   • C++/CLI projects can use Windows Forms and WPF APIs.
   • Add explicit framework references to the UI libraries.

   To use Windows Forms APIs, add this reference to the .vcxproj file:

   <!-- Reference all of Windows Forms -->
       <FrameworkReference Include="Microsoft.WindowsDesktop.App.WindowsForms" />
       

   To use WPF APIs, add this reference to the .vcxproj file:

   <!-- Reference all of WPF -->
       <FrameworkReference Include="Microsoft.WindowsDesktop.App.WPF" />
       

   To use both Windows Forms and WPF APIs, add this reference to the .vcxproj file:

   <!-- Reference the entirety of the Windows desktop framework:     Windows Forms, WPF, and the types that provide integration between them -->
       <FrameworkReference Include="Microsoft.WindowsDesktop.App" />
       

Remember that there are some limitations when migrating C++/CLI projects to .NET Core, such as not being able to compile to an executable directly and Windows-only support for C++/CLI. Make sure to check the documentation for more details

1. Upgrading a .NET 4.x Project to .NET 8.0

   1. Open the Project File:

      • In Visual Studio, navigate to Solution Explorer.

      • Right-click on the ManagedTest project and select "Upgrade"

        Refer: How to use upgrade assistant)

   2. Update the Project Configuration:

      • Locate the <TargetFramework> property and change its value to net8.0-windows. This specifies that the project targets the latest .NET 8.0 framework for Windows.
      • Find the <Platforms> property and set it to x64. This indicates that the project is built for the 64-bit architecture.

   3. Configure Assembly Search Paths:

      • Locate the <AssemblySearchPaths> property (it might not exist yet).
      • Add the path to your ObjectARX SDK directory within the property's value. This ensures that .NET references from the SDK are found during compilation. Here's an example structure:

      XML

                  <AssemblySearchPaths>$(OutDir);$(ReferencePath);C:\Path\To\Your\ObjectARX\SDK</AssemblySearchPaths>
                  
                

      • Replace C:\Path\To\Your\ObjectARX\SDK with the actual path to your ObjectARX SDK installation.

2. Optional: Update Root Namespace (if necessary):

   • If your project uses a specific root namespace to organize its files, locate the <RootNamespace> property and ensure it matches your project directory name.

3. Save the Project File:

   • Save the changes made to the project file (ManagedTest.csproj).

Here is the sample project file for your reference

    <?xml version="1.0" encoding="utf-8"?>
    <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
    <OutputType>Library</OutputType>
    <RootNamespace>ManagedTest</RootNamespace>
    <TargetFramework>net8.0-windows</TargetFramework>
    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
    <ObjectARXPATH Condition="'$(ObjectARXPATH)' == ''">D:\ArxSdks\arx2025</ObjectARXPATH>
    <AssemblySearchPaths>$(ObjectARXPATH)\inc\;$(AssemblySearchPaths)</AssemblySearchPaths>
    <Platforms>x64</Platforms>
    </PropertyGroup>
    <ItemGroup>
    <FrameworkReference Include="Microsoft.WindowsDesktop.App"/>
    </ItemGroup>
    <ItemGroup>
    <ProjectReference Include="..\ManagedWrapper\ManagedWrapper.vcxproj" />
    </ItemGroup>
    <ItemGroup>
    <Reference Include="AcDbMgd">
    <Private>False</Private>
    </Reference>
    <Reference Include="AcMgd">
    <Private>False</Private>
    </Reference>
    <Reference Include="AcCoreMgd">
    <Private>False</Private>
    </Reference>
    </ItemGroup>
    </Project>   
  

The Github project is available at ManagedCircle

Working with Unicode Text: Reading from and Writing to Files

By Madhukar Moogala

Before AutoCAD 2021, AutoLisp/VLisp was not fully Unicode compliant.

AutoCAD 2021 introduced a new system variable, LISPSYS, which fully supports AutoLisp functions with Unicode characters.

Here's how to read a text file with Unicode characters and create an MTEXT entity with the parsed contents:

Sample text file with Unicode characters:

こんにちは、良い一日を

The following AutoLisp code reads the text file and creates an MTEXT entity

  (defun c:drawtext()
   (setq f (open "d:/temp/r.txt" "r" "utf8"))
   (setq mytext (read-line f))
   (setq mypoint (list 1.0 1.0 0.0)
         myotherpoint (list -0.5 2.0 0.0)
         mycolor "2" ; red
         myrot 90.0
         currcolor (getvar "CECOLOR")
   )
   (setvar "CECOLOR" mycolor)
   (command "mtext" mypoint "R" myrot "@" mytext "")
   (setvar "CECOLOR" currcolor)
   (close f)
  )
  

Note:We use utf8encoding, which tells AutoLISP to open a Unicode stream for reading and writing.

Now, similarly, we can write the Unicode contents of an MTEXT entity to a file:

  (defun c:writetext()
  (setq f (open "d:/temp/w.txt" "w" "utf8"))
  (setq txt (vla-get-textstring (vlax-ename->vla-object (car (entsel "Pick mtext")))))
  (write-line txt f)
  (close f)
  )

Here's the result: