AutoCAD DevBlog

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