Real-Time AutoCAD Command Monitoring with ASP.NET SignalR

Introduction

What is ASP.NET SignalR? From to Microsoft's ASP.NET website, it says:

ASP.NET SignalR is a new library for ASP.NET developers that makes developing real-time web functionality easy. SignalR allows bi-directional communication between server and client. Servers can now push content to connected clients instantly as it becomes available. SignalR supports Web Sockets, and falls back to other compatible techniques for older browsers. SignalR includes APIs for connection management (for instance, connect and disconnect events), grouping connections, and authorization.

Go to here for more information on ASP.NET SignalR. Searching the Internet would bring up tons of links on this technology, including code samples. tutorials. While this technology is mainly meant for web application, it does support .NET client.

In my recent web application study/development, I had opportunity to explore this technology a little bit. Just a months ago, I explored using ASP.NET Web API to automate AutoCAD. I thought why not to give it a try to make ASP.NET SignalR and AutoCAD work together? 

Since SignalR is about bi-directional communication between server and client and primarily meant for web browser as the client side UI, I felt it would be interesting to make a running AutoCAD to communicate with a web browser.

The core of communication via SignalR is a set of API, called Hub API, hosted somewhere as communication server, the clients (multiple web browsers) talk to each other via the Hub. Like Web API, SignalR can either be hosted in a web server (IIS), or be self-hosted (as a console application, Windows service application...).

Many AutoCAD programmers may have done (or been asked to develop) something that monitors AutoCAD usage at some point. I did this kind of applications with AutoCAD VBA and .NET API. So, I decide to see how easy (or how difficult) to build a simple application that can monitor AutoCAD usage in real-time mode by tracking AutoCAD commands executed by an AutoCAD user. I did not mean to create an application that has practical value, just want it to be a proof of concept.

Here are couple of development considerations:

1. I decided to self-host SignalR's server in a console application. Thus my code can run with any Windows computer with .NET 4.5 installed without relying on a web server somewhere on the network for hosting SignalR server.

2. Since SignalR requires .NET 4.5, the AutoCAD add-in that uses SignalR .NET client API must also target 4.5. Although latest AutoCAD (2013/2014) only officially support .NET 4.0, AutoCAD NET add-in built on .NET 4.5 should work OK in general.

A Pilot Development
 

I started with a Visual Studio 2013 solution with 4 projects in it:

 

 

1. Project SignalRSelfHost

A console application that host SignalR's Hub API. For this project, NuGet Package Microsoft ASP.NET SignalR Self Host is added, which also brings in a few other dependency packages, such as Microsoft.Owin, NewtonSoft.Json.

The code of this project looks like:

using Microsoft.AspNet.SignalR;
using Microsoft.Owin.Cors;
using Microsoft.Owin.Hosting;
using Owin;
using SignalRCadData;
using System;
 
namespace SignalRSelfHost
{
    class Program
    {
        static void Main(string[] args)
        {
            string url = "http://localhost:8080";
            using (WebApp.Start(url))
            {
                Console.Write("server running on {0}", url);
                Console.WriteLine("Press any key to exit...");
                Console.ReadLine();
            }
        }
    }
 
    class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            app.UseCors(CorsOptions.AllowAll);
            app.MapSignalR();
        }
    }
 
    public class MyHub : Hub
    {
        //Test method, not used in this blog
        public void Send(string name, string message)
        {
            Clients.All.addMessage(name, message);
        }
 
        //AutoCAD calls this method by sending an 
        //AcadCommandTrack object to MyHub
        public void RelayAcadMessage(AcadCommandTrack cmdTrack)
        {
            //Write to console, in order to see the server does
            //receive calls from SignalR client
            Console.Write("Received data: " + cmdTrack.ToString());
 
            //MyHub calls all connected clients where an Action
            //named as "getAcadMessage" (function in JavScript)
            //will do something on the client side
            Clients.All.getAcadMessage(cmdTrack.ToString());
 
            Console.WriteLine("...data has been sent to client.");
            Console.WriteLine("Press any key to exit...");
        }
    } 
}

Note: I came across an exception when running the console application the first time. It turned out the Microsoft.Owin.Security package brought in by Microsoft ASP.NET SignalR Self Host package as dependency package were out-of-date. After added Microsoft.Owin.Security package separately, the exception went away:

2. Project SignalRCadData

This project only contains a simple data model class AcadCommandTrack:

using System;
 
namespace SignalRCadData
{
    public class AcadCommandTrack
    {
        public string UserName { set; get; }
        public string ComputerName { set; get; }
        public string CommandName { set; get; }
        public DateTime CmdExecTime { set; get; }
        public string DwgFileName { set; get; }
 
        public override string ToString()
        {
            return "Command \"" + CommandName + "\"" +
                " executed in drawing \"" + DwgFileName + "\"" +
                " at " + CmdExecTime.ToLongTimeString() +
                " on computer \"" + ComputerName + "\"" +
                " by \"" + UserName + "\"";
        }
 
        public AcadCommandTrack()
        {
            UserName = "None";
            ComputerName = "None";
            CommandName = "None";
            CmdExecTime = DateTime.Now;
            DwgFileName = "";
        }
    }
}

3. Project JavaScriptClient

This project is a web application with a single and simple HTML page AcadCmdTrack.html (the Default.html was created for test purpose, which I did not bother to remove it). To be able to act as SignalR client running inside a web browser, the NuGet package Microsoft ASP.NET SignalR JavaScript Client must be added into this project:

The AcadCmdTrack.html page's markup and JavaScript are quite simple:

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>AutoCAD Command Tracking</title>
    <style type="text/css">
        .container {
            background-color: #99CCFF;
            border: thick solid #808080;
            padding: 20px;
            margin: 20px;
        }
    </style>
</head>
<body>
    <div class="container">
        <ul id="discussion"></ul>
    </div>
    <!--Script references. -->
    <!--Reference the jQuery library. -->
    <script src="Scripts/jquery-1.6.4.min.js"></script>
    <!--Reference the SignalR library. -->
    <script src="Scripts/jquery.signalR-2.0.2.min.js"></script>
    <!--Reference the autogenerated SignalR hub script. -->
    <script src="http://localhost:8080/signalr/hubs"></script>
    <!--Add script to update the page and send messages.-->
    <script type="text/javascript">
        $(function () {
            //Set the hubs URL for the connection
            $.connection.hub.url = "http://localhost:8080/signalr";
 
            // Declare a proxy to reference the hub.
            var chat = $.connection.myHub;
 
            // Create a function that the hub can call to broadcast messages.
            chat.client.getAcadMessage = function (message) {
                // Html encode display name and message.
                var encodedMsg = $('<div />').text(message).html();
                // Add the message to the page.
                $('#discussion').append('<li><strong>' + encodedMsg + '</li>');
            };
 
            // Start the connection.
            $.connection.hub.start();
        });
    </script>
</body>
</html>

In the JavaScript, we can see how the web page makes connection to the SignalR server's hub MyHub:

var chat = $.connection.myHub;

and how it defines a function getAcadMessage() so that the SignalR hub on the server side can call an action on the client side.

 

4. Project ConsoleClient

Before I jumped into AutoCAD, I decided to first create a simple console application as a SignalR .NET client to simulate the work of AutoCAD: sending message (represented by class AcadCommandTrack) to SignalR server, so that the message can be instantly shown in web browser (that is, the web browser works like a real time monitor of an AutoCAD session).

The NuGet package Microsoft ASP.NET SignalR .NET Client must be added to this project:

Here is the code for this project:

using Microsoft.AspNet.SignalR.Client;
using System;
using SignalRCadData;
 
namespace ConsoleClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Connecting SignalR server...");
 
            var hubConnection = new HubConnection("http://localhost:8080");
 
            bool connected = true;

 
            //IHubProxy must be created before the connection's Start()
            IHubProxy hubProxy = hubConnection.CreateHubProxy("MyHub");
            hubConnection.Start().ContinueWith(task =>
                {
                    if (task.IsCompleted)
                    {
                        Console.WriteLine("Connected successfully.");
                    }
                    else
                    {
                        connected = false;
                        Console.WriteLine("Cannot connect to server: {0}", 
                            task.Exception.GetBaseException().Message);
                    }
                }).Wait();
            
            if (!connected)
            {
                Console.WriteLine("Press any key to exit...");
                Console.ReadLine();
            }
            else
            {
                //This make this client gets server call on the 
                //Action 'getAcadMessage'
                hubProxy.On<string>("getAcadMessage", param =>
                {
                    Console.WriteLine(param);
                });
 
                string serverMethod = "RelayAcadMessage";
                Console.WriteLine("Enter M to send message, or press Enter to exit...");
                while(true)
                {     
                    string input = Console.ReadLine();
                    if (string.IsNullOrEmpty(input)) break;
 
                    //Call the server's RelayAcadMessage() method with
                    //AcadCmdTrack object passed in.
                    //Then all connected SignalR clients will be called
                    //by the server, as long as an Action called
                    //'getAcadMessage' is defined inside the client
                    hubProxy.Invoke<AcadCommandTrack>(
                        serverMethod,
                        new AcadCommandTrack
                        {
                            CommandName = "EDM-YUAN",
                            UserName = "norman.yuan",
                            ComputerName = "LINE",
                            CmdExecTime = DateTime.Now,
                            DwgFileName="Xxxxxx.dwg"
                        }).ContinueWith(task =>
                            {
                                if (task.IsCompleted)
                                {
                                    Console.WriteLine("AcadCommandTrack message is sent.");
                                }
                                else
                                {
                                    Console.WriteLine("Calling \"" + serverMethod + "\" failed: {0}", 
                                        task.Exception.GetBaseException().Message);
                                }
                            }).ContinueWith(c=>
                                {
                                    Console.WriteLine("Enter M to send message, or press Enter to exit...");
                                });
                }
 
                hubConnection.Stop();
                hubConnection.Dispose();
            }
        }
    }
}

After the solution is built successfully, it is time to give it a try. In order to be able to make the server and clients projects all start, I right-clicked the solution in the Solution Explorer, and selected "Set Startup Project...":

so that the server project is started before the client projects.

Here is the video clip showing how they work together as server-client communication goes.


Put AutoCAD In Action

With the success of the solution SignalR_Study, I then brought AutoCAD into the picture in a second Visual Studio solution AcadSignalRStudy:

The solution added the project SignalRCadData from the first solution as external project, so that the AutoCAD addin project AcadSignalRClient can haave reference to it.

The project AcadSignalRClient targets .NET 4.51 because of the requirement of SignalR 2.0. According to Microsoft, the SignalR client can be in older version of SignalR server. That means I could have used older version of SignalR client, so that my AutoCAD addin can still target .NET 4.0. However, using .NET 4.51 in this AutoCAD addin did not cause any issue.

Here is the idea of the entire thing:

I am an very picky boss who supervise a bunch of CAD users. I want to analyse how a Cad user does a particular drafting task by monitoring what commands he/she uses to fulfill that task. So, I do:

• Set up a SignalR server
• In AutoCAD, I ask the user turn on AutoCAD command real-time tracking addin
• Launch a SignalR client web application in my web browser, start watching how user commands AutoCAD working.

What the AutoCAD addin does is basically handling Document.CommandWillStart event. In the event handler a SignalR client (IHubProxy object) collect information on current AutoCAD command and sends the information to SignalR server. The SignalR server in turn sends the information to the connected web browser.

Here is the code for the AutoCAD addin:

using System;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
using Microsoft.AspNet.SignalR.Client;
 
[assembly: CommandClass(typeof(AcadSignalRClient.MyCommands))]
 
namespace AcadSignalRClient
{
    public class MyCommands
    {
        private static bool _trackCommand = false;
        private static HubConnection _hubConnection = null;
        private static IHubProxy _hubProxy = null;
        private const string HOST_URL = "http://localhost:8080";
 
        [CommandMethod("TrackCmd", CommandFlags.Session)]
        public static void RunMyCommand()
        {
            Document dwg = Application.DocumentManager.MdiActiveDocument;
            Editor ed = dwg.Editor;
 
            if (!_trackCommand)
            {
                try
                {
                    ed.WriteMessage(
                        "\nConnecting to SignalR server...");
 
                    //Attach event handler to DocumentCollection/Document
                    AttachDocumentEventHandlers();
 
                    //Setup SignalR client
                    bool connected = CreateHubConnection();
                    if (connected)
                    {
                        ed.WriteMessage(
                            "\nConnection to SignalR server established!");
                        _trackCommand = true;
                    }
                    else
                    {
                        _trackCommand = false;
                        throw new InvalidOperationException(
                            "cannot connect to SignalR server at " + HOST_URL);
                    } 
    
                    if (_trackCommand)
                    {
                        ed.WriteMessage("\nCommand tracking is on.");
                    }
                }
                catch (System.Exception ex)
                {
                    ed.WriteMessage("\nError: {0}", ex.Message);
 
                    _trackCommand = false;
                    _hubConnection = null;
                    _hubProxy = null;
                }
            }
            else
            {
                _hubConnection.Stop();
                _hubConnection.Dispose();
                _hubConnection = null;
                _hubProxy = null;
 
                ed.WriteMessage("\nCommand tracking is off.");
            }
 
            Autodesk.AutoCAD.Internal.Utils.PostCommandPrompt();
        }
 
        #region private methods
 
        private static bool CreateHubConnection()
        {
            _hubConnection = new HubConnection(HOST_URL);
            _hubProxy = _hubConnection.CreateHubProxy("MyHub");
 
            bool connected = true;
 
            _hubConnection.Start().ContinueWith(task =>
            {
                if (!task.IsCompleted)
                {
                    connected = false;
                }
            }).Wait();
 
            return connected;
        }
 
        private static void AttachDocumentEventHandlers()
        {
            Document dwg = Application.DocumentManager.MdiActiveDocument;
            dwg.CommandWillStart += dwg_CommandWillStart;
 
            Application.DocumentManager.DocumentCreated += 
                DocumentManager_DocumentCreated;
            Application.DocumentManager.DocumentToBeDestroyed += 
                DocumentManager_DocumentToBeDestroyed;
        }
 
        private static void DocumentManager_DocumentToBeDestroyed(
            object sender, DocumentCollectionEventArgs e)
        {
            e.Document.CommandWillStart -= dwg_CommandWillStart;
        }
 
        private static void DocumentManager_DocumentCreated(
            object sender, DocumentCollectionEventArgs e)
        {
            e.Document.CommandWillStart += dwg_CommandWillStart;
        }
 
        private static void dwg_CommandWillStart(
            object sender, CommandEventArgs e)
        {
            if (!_trackCommand) return;
 
            Document dwg = Application.DocumentManager.MdiActiveDocument;
            Editor ed = dwg.Editor;
            ed.WriteMessage("\nCommand {0} is about to start...", 
                e.GlobalCommandName.ToUpper());
 
            string dwgFileName = System.IO.Path.GetFileName(dwg.Name);
 
            SendMessageToSignalRServer(e.GlobalCommandName, dwgFileName);
        }
 
        private static void SendMessageToSignalRServer(
            string cmdName, string dwgFileName)
        {
            if (_hubConnection == null) return;
 
            string user = Environment.UserName;
            string computer = Environment.MachineName;
 
            SignalRCadData.AcadCommandTrack atrck = 
                new SignalRCadData.AcadCommandTrack()
                {
                    UserName = user,
                    ComputerName = computer,
                    CommandName = cmdName,
                    CmdExecTime = DateTime.Now,
                    DwgFileName=dwgFileName
                };
 
            //Call the hub method "RelayAcadMessage()" on 
            //SignalR server side
            _hubProxy.Invoke<SignalRCadData.AcadCommandTrack>(
                "RelayAcadMessage", atrck);
        }
 
        #endregion
    }
}

 

After the code was built successfully, I started run the projects in solution SignalR_Study first. Then I started solution "AcadSignalRStudy", which launches AutoCAD2014. after loading the addin DLL into AutoCAD, I entered the command "TrackCmd" to turn on monitoring to execution of AutoCAD commands. From this moment on, any command started can be watched in the monitoring web browser, until the command tracking process is turned off.

See this video clip showing how AutoCAD commands are monitored in real-time.


Final Thought

With the computing power moving to the Internet/cloud, more and more user applications run inside web browser instead of being native desktop application. Being so easily communicate an application inside an web browser by using SignalR is certainly a good thing to know and to use, when there is real business need. This article is just a scratch of it. While we AutoCAD programmers are still enjoying the ease and powerful AutoCAD .NET API when developing against one of the most important, traditional desktop application - AutoCAD, we should expand our programming knowledge/skill to embrace the coming tide of cloud based computing. ASP.NET SignalR is one of those things we could learn and get benefited from it, for now, at least.

Download the source code here.