I have found a better implementation without calling the DotNetWrapper every time.
(defun JO:Netload (files / *error* cmdecho)
  (defun *error* (msg / )
    (and cmdecho (setvar 'cmdecho cmdecho))
    (princ "; error: ")
    (princ msg)
    (princ)
  )
  (defun JO:*error* (msg / *error*)
    (defun *error* (msg)
      (princ)
    )
    (princ "\n; error: ")
    (princ msg)
    (nil)
  )
 
  (setq cmdecho (getvar 'cmdecho))
  (setvar 'cmdecho 0)
 
  (foreach file files
    (command-s "NETLOAD" file)
  )
 
  (setvar 'cmdecho cmdecho)
  (setq cmdecho nil)
 
  (vl-acad-defun 'JO:*error*)
  (princ)
)

Call with:
(JO:Netload '("C:/Users/jtoverka/Desktop/NetDBX Library.dll"))

.NET function:
/// <summary>
/// Invokes a Lisp error message.
/// </summary>
/// <param name="message"></param>
/// <remarks>
/// This will trigger the end of the running lisp function.
/// </remarks>
public static void ThrowLispError(string message)
{
    try
    {
        using ResultBuffer error = new ResultBuffer(
            new TypedValue((int)LispDataType.Text, "JO:*error*"),
            new TypedValue((int)LispDataType.Text, message));

        ResultBuffer rtn = Application.Invoke(error);
    }
    catch (System.Exception e)
    {
        Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
        ed.WriteMessage($"\n; error: {message}\n");
        ed.WriteMessage($"\n; Unhandled LISP Error Exception: {e.Message}\n");
    }
}
As long as the .NET code invokes the "JO:*error*" autolisp function.

The only way to truly improve upon this implementation is the ability to create and evaluate lambda Lisp functions in .NET without the need for vl-acad-defun. If anyone knows how to do this, or something equivalent, please share 

Much of the amazing stuff in the "show your stuff" threads tend to get hidden. I only recently browsed those threads. It was funny because I recall almost being in tears trying to get an AutoLISP code to work (prevailed none the less) only to see the exact code in the "show your stuff"... just a better version.

I kind of wish there was a way to get more attention/credit to all the nifty code snippets provided here... for free none the less.

This seems to work:
if /I [%~x1]==[.DWG] (echo "[%count%/%argc%]: Processing... %~f1" ) else (echo "[%count%/%argc%] skipping %~f1" )
if /I [%~x1]==[.DWG] (call "C:\Program Files\Autodesk\AutoCAD 2021\accoreconsole.exe" /i "%~f1" /s %script% /l en-US >"C:\temp\cleanup.log")

There is one problem I found.  If any of the file names or folders have the '&' character it doesn't work.

 

No sweat MP, just a small vent
Stay well!

Using the great code by MP for the DST->XML functions, by Lee Mac for the Table and DCL functions, and J. Szewczak for the XML functions, I put together the attached sheetset functions, some more useful than others. I'm sure anything written by me could be improved. I think this was the second time I played with DCL, so there was a lot of guess-and-check going on.

I think the most useful function in here is the "sstable" function that lets you create a regular autocad table from multiple dst files. This is handy for when you have separate dst's for each discipline in a project. I tried to mimic the built in method to create a sheet list table from the SSM, where you can specify the column headings for whatever property you want in the table. It stores an xrecord in the drawing, and uses it as defaults for the next time you run it. It's not very fast, but much faster than built in methods. Our projects are pretty big (Ports and Harbors, Marine structures).

There is also a function to index a sheet property ("indexss"), which is handy for the X in "sheet X of XX".

Hope for can find it useful!


Big thanks to MP, Lee Mac, and J. Szewczak!


Steve