AutoCAD .NET: Criando Seu Próprio Template em Visual Studio

Eu trabalho numa empresa não muito grande mas que não permite que as pessoas instalem aplicativos nos computadores, assim, não posso instalar nada sobre o Visual Studio.

Isso é um problema porque a Autodesk fornece o AutoCAD .NET Wizards que é um instalador de Templates já prontos para iniciar aplicações em .NET para AutoCAD.

Como não posso instalar me veio a ideia de montar meu próprio template.

1. Criando um projeto novo

O primeiro passo é criar um projeto novo, neste caso criei um projeto no Visual Studio 2013 em .NET Framework 4 porque estou trabalhando com o AutoCAD 2014.

2. Adicionando as referências

Para começar a desenvolver o projeto teremos que primeiro adicionar as Referências do AutoCAD .NET que estão no pacote Object ARX que você já deve ter feito DOWNLOAD no site da Autodesk.

O mínimo que você deve adicionar ao seu projeto são as seguintes dll's: "AcTcMgd.dll" "AcCoreMgd.dll" "AcDbMgd.dll" "AcMgd.dll" que estão no caminho: C:\Autodesk\Autodesk_ObjectARX_2014\inc

É importante que todas as DLL carregadas estejam na condição Copy Local em False. Isso faz com que o AutoCAD se mantenha usando as DLL que já estão carregadas nele.

3. Criando a estrutura mínima

O template padrão possuí pelo menos duas classes: 

1. Classe de Comandos: Onde serão carregados todos os comandos que serão feitos nessa DLL para o AutoCAD

2. Classe Plug-in de Inicialização e Terminação do processo atribuído a classe.

Então, dentro do projeto teremos que criar essas duas classes.

Como criei a partir de um projeto de DLL veio uma classe chamada Class1.cs, renomeei para Plugin.cs. Poderia ter colocado outro nome o que vai torna-lo o necessário para carregar uma DLL é o código abaixo:

using Autodesk.AutoCAD.Runtime;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace AutoCAD_2014_Class_Library

{

    // This class is instantiated by AutoCAD once and kept alive for the

    // duration of the session. If you don't do any one time initialization

    // then you should remove this class.

    public class Plugin : IExtensionApplication

    {

        void IExtensionApplication.Initialize()

        {

            // Add one time initialization here

            // One common scenario is to setup a callback function here that

            // unmanaged code can call.

            // To do this:

            // 1. Export a function from unmanaged code that takes a function

            //    pointer and stores the passed in value in a global variable.

            // 2. Call this exported function in this function passing delegate.

            // 3. When unmanaged code needs the services of this managed module

            //    you simply call acrxLoadApp() and by the time acrxLoadApp

            //    returns  global function pointer is initialized to point to

            //    the C# delegate.

            // For more info see:

            // http://msdn2.microsoft.com/en-US/library/5zwkzwf4(VS.80).aspx

            // http://msdn2.microsoft.com/en-us/library/44ey4b32(VS.80).aspx

            // http://msdn2.microsoft.com/en-US/library/7esfatk4.aspx

            // as well as some of the existing AutoCAD managed apps.

            // Initialize your plug-in application here

                     

        }

        void IExtensionApplication.Terminate()

        {

            // Do plug-in application clean up here

        }

    }

}

Nesse código já se utiliza o Autodesk.AutoCAD.Runtime para criar a classe de "gerenciamento de inicialização e terminação" que é do tipo unico IExtensionApplication.

Essa classe mandatória tem que ter essas duas funções com retorno nulo (void):

IExtensionApplication.Initialize() função que permite que você inicialize a classe. Geralmente nos meus códigos eu inicializo um log de eventos nesse ponto para que conseguir depurar o que algum usuário fez.

IExtensionApplication.Terminate() função de finalização da classe, nesse ponto eu escrevo os logs e fecho os TextWrite object's.


O próximo passo é criar a classe de comandos.
Essa classe também precisa do using Autodesk.AutoCAD.Runtime; 
Então ficamos com o código assim:

using System;

using Autodesk.AutoCAD.Runtime;

// This line is not mandatory, but improves loading performances

[assembly: CommandClass(typeof(AutoCAD_2014_Class_Library.Comandos))]

namespace AutoCAD_2014_Class_Library

{

    // This class is instantiated by AutoCAD for each document when

    // a command is called by the user the first time in the context

    // of a given document. In other words, non static data in this class

    // is implicitly per-document!

    public class Comandos

    {

        /// <summary>

        /// Mostra o log de eventos da função do Plug-in.

        /// </summary>       

        [CommandMethod("comando_teste", CommandFlags.Modal)]

        public void comando_de_teste() // This method can have any name

        {

            System.Windows.Forms.MessageBox.Show("Isso é Um teste!", "Meu Template");

        }

    }

}

Esse código tem essa linha bizarra [assembly: CommandClass(typeof(AutoCAD_2014_Class_Library.Comandos))] que segundo a Autodesk melhora a performance dos comandos.

De resto é o que você já está acostumado, uma classe Comandos com um comando de teste que se chamará no prompt por comando_teste.

Estamos prontos para lançar a aplicação agora vamos configurar como chamar o AutoCAD.

3. Modificando o AssemblyInfo

Para carregar a DLL corretamente é necessário adicionar uma informação no AssemblyInfo

// In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing.//// Use the attributes below to control which key is used for signing.
//// Notes:
//   (*) If no key is specified, the assembly is not signed.//   (*) KeyName refers to a key that has been installed in the Crypto Service//       Provider (CSP) on your machine. KeyFile refers to a file which contains//       a key.//   (*) If the KeyFile and the KeyName values are both specified, the
//       following processing occurs://       (1) If the KeyName can be found in the CSP, that key is used.//       (2) If the KeyName does not exist and the KeyFile does exist, the key
//           in the KeyFile is installed into the CSP and used.//   (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.//       When specifying the KeyFile, the location of the KeyFile should be//       relative to the project output directory which is//       %Project Directory%\obj\<configuration>. For example, if your KeyFile is//       located in the project directory, you would specify the AssemblyKeyFile
//       attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]//   (*) Delay Signing is an advanced option - see the Microsoft .NET Framework//       documentation for more information on this.[assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyFile("")]
[assembly: AssemblyKeyName("")]

4. Chamando o AutoCAD

Vamos então nas propriedades do projeto em Debug. Em Start Action ao invés da opção Start project selecionaremos o acad.exe na pasta onde está localizado. Dessa forma o AutoCAD será aberto ao invés da DLL (o que já não iria acontecer).

Em Start Options faremos as configurações para abrir o nosso desenho de teste. Para isso, como o AutoCAD será aberto partindo da pasta bin\debug vamos colocar lá em ....\Documents\Visual Studio 2013\Projects\AutoCAD 2014 Class Library\AutoCAD 2014 Class Library\bin\Debug o arquivo de exemplo que chamaremos de "CAD_TEST_DRAWING.dwg".

Então vamos escrever em Start Options: ""CAD_TEST_DRAWING" /product ACAD /language "en-US" /nologo"

O restante do texto é para deixar o AutoCAD abrir sem o logo de inicialização o que o deixa mais rápido para abrir.

4. Testando

Bom agora o Projeto de Template está pronto vamos fazer um teste depurando o código. O AutoCAD deve abrir e poderemos carregar a DLL e executar o comando_teste.

Agora já estamos prontos para voltar ao Visual Studio e transformar esse projeto em um Template.

5. Transformando em um Template

Existe um Wizard do Visual Studio para criação de Templates a partir de projetos já prontos no Menu File > Export Template ...

O menu é bem empírico e no final você consegue ter um projeto *.zip modelo para novos projetos.

E finalmente nos podemos abrir um novo projeto e lá estará o nosso template.

Faça DOWNLOAD aqui do template que fiz nesse post.