AutoCAD DevBlog

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

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

Autodesk Desktop API Update: .NET Core Migration

By Madhukar Moogala

On January 30th, 2024, we hosted a webinar on moving to .NET core covering Autodesk's flagship products, AutoCAD, Revit, and Inventor.

Please find the posting of recording of the same on YouTube

https://youtu.be/RyHx5-CqKZM?si=AyBIjZMvoleAjjNT

Webinar Presentation

- Slide Deck

AutoCAD .NET migration guide

- How to Create, Build and Debug .NET 8  Plugin for AutoCAD 2025.pdf

- How to Create, Build and Debug .NET 8  Plugin for AutoCAD 2025.mp4

- How to Create, Build and Debug .NET 8.0  Plugin for AutoCAD 2025 (VS 2022).pdf

How to Check if BEDIT–Is Saved or Discarded

By Madhukar Moogala

This is in continuation to How to Check if XREF Edit In Place Is Saved or Discarded - AutoCAD DevBlog (typepad.com)

I have received query how similar thing can be achieved for Block Edit in place.

We can retrieve this information from acedGetBlockEditMode

class XrefCheckEditor : public AcEditorReactor {

virtual void commandEnded(const TCHAR* cmdStr) {
if (wcscmp(cmdStr, L"REFCLOSE") == 0)
{
			
	switch (EditInPlaceXref::XrefState)
	{
	case EditInPlaceXref::Saved:
		acutPrintf(L"\n Modifications To In External Reference Are Saved");
		EditInPlaceXref::Reset();
		break;
	case EditInPlaceXref::Discarded:
		acutPrintf(L"\n Modifications To In External Reference Are Discarded");
		break;
	default:
		break;
	}

}
if (wcscmp(cmdStr, L"BCLOSE") == 0) {
	const bool bSaveHappened = (::acedGetBlockEditMode() & kBlkEditModeBSaved) != 0;
	if (bSaveHappened)
	{
		acutPrintf(L"\n Block Reference is Saved");
	}
	else
	{
		acutPrintf(L"\n Block Reference is Not Saved");
	}
}
}
};

How to embed a property inspector control into a palette

By Madhukar Moogala

This is old SDK Sample I have resurrected for better reach, the code is migrated to work with AutoCAD 2023.

This sample demonstrates deriving from CAdUiPalette and CAdUiPaletteSet.

· How to persist palette data into an XML file, and to re-establish the palette set when newly created.

· How to embed a property inspector control into a palette.

· How to create a custom property editor ActiveX control (CDWGPreview).

Source :

https://github.com/MadhukarMoogala/CustPalette