Accessing CAD+ Toolset Macro+ framework form the xCAD Macro (.NET)

[XCadMacro]
[Title("Sample xCAD Macro")]
[Description("Exampe of xCAD macro in C#")]
[Icon(typeof(Resources), nameof(Resources.macro_icon))]
public class XCadMacroSample : IXCadMacro
{
    public void Run(IJobItemRunMacroOperation operation)
    {
    }
}

<XCadMacro>
<Title("Sample xCAD Macro")>
<Description("Exampe of xCAD macro in C#")>
<Icon(GetType(Resources), NameOf(Resources.macro_icon))>
Public Class XCadMacroSample
    Implements IXCadMacro
    Public Sub Run(ByVal operation As IJobItemRunMacroOperation) Implements IXCadMacro.Run
    End Sub
End Class

IXApplication app = operation.Application;
IXDocument doc = operation.Document;

Dim app As IXApplication = operation.Application
Dim doc As IXDocument = operation.Document

foreach (IXCadMacroArgument arg in operation.Arguments) 
{
    var argVal = arg.GetValue();
}

For Each arg As IXCadMacroArgument In operation.Arguments
    Dim argVal = arg.GetValue()
Next

public class MyContext 
{
    public string Data { get; }

    public MyContext(string data)
    {
        Data = data;
    }
}

public class MyMacroVariableValueProvider : VariableValueProvider<MyContext>
{
    public const string VAR_MY_VAR_NAME = "myVar";

    public override object Provide(string name, object[] args, MyContext context)
    {
        switch (name)
        {
            case VAR_MY_VAR_NAME:
                return "My Variable Value";

            default:
                throw new NotSupportedException();
        }
    }
}

public class MyMacroVariableLinks : List<IExpressionVariableLink>
{
    public MyMacroVariableLinks()
    {
        Add(new ExpressionVariableLink("MyVar", "My Variable", Resources.variable_icon.ToBitmapImage(true),
            s => new ExpressionTokenVariable(MyMacroVariableValueProvider.VAR_MY_VAR_NAME, null), false));
    }
}

public class MyMacroVariablesDescriptor : IExpressionVariableDescriptor
{
    public ExpressionVariableArgumentDescriptor[] GetArguments(IExpressionTokenVariable variable, out bool dynamic)
    {
        switch (variable.Name)
        {
            case MyMacroVariableValueProvider.VAR_MY_VAR_NAME:
                dynamic = false;
                return null;

            default:
                throw new NotSupportedException();
        }
    }

    public System.Windows.Media.Brush GetBackground(IExpressionTokenVariable variable)
    {
        switch (variable.Name)
        {
            case MyMacroVariableValueProvider.VAR_MY_VAR_NAME:
                return System.Windows.Media.Brushes.LightBlue;

            default:
                throw new NotSupportedException();
        }
    }

    public string GetDescription(IExpressionTokenVariable variable)
    {
        switch (variable.Name)
        {
            case MyMacroVariableValueProvider.VAR_MY_VAR_NAME:
                return "My Variable";

            default:
                throw new NotSupportedException();
        }
    }

    public System.Windows.Media.ImageSource GetIcon(IExpressionTokenVariable variable)
    {
        switch (variable.Name)
        {
            case MyMacroVariableValueProvider.VAR_MY_VAR_NAME:
                return Resources.variable_icon.ToBitmapImage(true);

            default:
                throw new NotSupportedException();
        }
    }

    public string GetTitle(IExpressionTokenVariable variable)
    {
        switch (variable.Name)
        {
            case MyMacroVariableValueProvider.VAR_MY_VAR_NAME:
                return "MyVar";

            default:
                throw new NotSupportedException();
        }
    }
}

[XCadMacro]
[XCadMacroCustomVariables(typeof(MyMacroVariablesDescriptor),
    typeof(MyMacroVariableLinks),
    typeof(MyMacroVariableValueProvider),
    MyMacroVariableValueProvider.VAR_MY_VAR_NAME)]
public class MyXCadMacro : IXCadMacro

Public Class MyContext
    Public ReadOnly Property Data As String

    Public Sub New(ByVal data As String)
        Me.Data = data
    End Sub
End Class

Public Class MyMacroVariableValueProvider
    Inherits VariableValueProvider(Of MyContext)
    Public Const VAR_MY_VAR_NAME As String = "myVar"

    Public Overrides Function Provide(ByVal name As String, ByVal args As Object(), ByVal context As MyContext) As Object
        Select Case name
            Case VAR_MY_VAR_NAME
                Return "My Variable Value"
            Case Else
                Throw New NotSupportedException()
        End Select
    End Function
End Class

Public Class MyMacroVariableLinks
    Inherits List(Of IExpressionVariableLink)
    Public Sub New()
        Add(New ExpressionVariableLink("MyVar", "My Variable", Resources.variable_icon.ToBitmapImage(True), Function(s) New ExpressionTokenVariable(MyMacroVariableValueProvider.VAR_MY_VAR_NAME, Nothing), False))
    End Sub
End Class

Public Class MyMacroVariablesDescriptor
    Implements IExpressionVariableDescriptor
    Public Function GetArguments(ByVal variable As IExpressionTokenVariable, <Out> ByRef dynamic As Boolean) As ExpressionVariableArgumentDescriptor() Implements IExpressionVariableDescriptor.GetArguments
        Select Case variable.Name
            Case MyMacroVariableValueProvider.VAR_MY_VAR_NAME
                dynamic = False
                Return Nothing
            Case Else
                Throw New NotSupportedException()
        End Select
    End Function

    Public Function GetBackground(ByVal variable As IExpressionTokenVariable) As Windows.Media.Brush Implements IExpressionVariableDescriptor.GetBackground
        Select Case variable.Name
            Case MyMacroVariableValueProvider.VAR_MY_VAR_NAME
                Return Windows.Media.Brushes.LightBlue
            Case Else
                Throw New NotSupportedException()
        End Select
    End Function

    Public Function GetDescription(ByVal variable As IExpressionTokenVariable) As String Implements IExpressionVariableDescriptor.GetDescription
        Select Case variable.Name
            Case MyMacroVariableValueProvider.VAR_MY_VAR_NAME
                Return "My Variable"
            Case Else
                Throw New NotSupportedException()
        End Select
    End Function

    Public Function GetIcon(ByVal variable As IExpressionTokenVariable) As Windows.Media.ImageSource Implements IExpressionVariableDescriptor.GetIcon
        Select Case variable.Name
            Case MyMacroVariableValueProvider.VAR_MY_VAR_NAME
                Return Resources.variable_icon.ToBitmapImage(True)
            Case Else
                Throw New NotSupportedException()
        End Select
    End Function

    Public Function GetTitle(ByVal variable As IExpressionTokenVariable) As String Implements IExpressionVariableDescriptor.GetTitle
        Select Case variable.Name
            Case MyMacroVariableValueProvider.VAR_MY_VAR_NAME
                Return "MyVar"
            Case Else
                Throw New NotSupportedException()
        End Select
    End Function
End Class

<XCadMacro>
<XCadMacroCustomVariables(GetType(MyMacroVariablesDescriptor), GetType(MyMacroVariableLinks), GetType(MyMacroVariableValueProvider), MyMacroVariableValueProvider.VAR_MY_VAR_NAME)>
Public Class MyXCadMacro
    Implements IXCadMacro

public class MyResultFile : IJobItemOperationResultFile
{
    public string Path { get; }
    public JobItemOperationResultFileStatus_e Status { get; set; }

    public MyResultFile(string path)
    {
        Path = path;
        Status = JobItemOperationResultFileStatus_e.Initializing;
    }
}

var resFiles = new MyResultFile[]
{
    new MyResultFile(@"D:\file1.stp"),
    new MyResultFile(@"D:\file2.stp")
};

operation.SetResult(resFiles);

foreach (var resFile in resFiles) 
{
    try
    {
        //TODO: process the result file (e.g. export)
        resFile.Status = JobItemOperationResultFileStatus_e.Succeeded;
    }
    catch 
    {
        resFile.Status = JobItemOperationResultFileStatus_e.Failed;
    }
}

Public Class MyResultFile
    Implements IJobItemOperationResultFile
    Public ReadOnly Property Path As String Implements IJobItemOperationResultFile.Path
    Public Property Status As JobItemOperationResultFileStatus_e Implements IJobItemOperationResultFile.Status

    Public Sub New(ByVal path As String)
        Me.Path = path
        Status = JobItemOperationResultFileStatus_e.Initializing
    End Sub
End Class

Dim resFiles = New MyResultFile() {New MyResultFile("D:\file1.stp"), New MyResultFile("D:\file2.stp")}

operation.SetResult(resFiles)

For Each resFile In resFiles
    Try
        'TODO: process the result file (e.g. export)
        resFile.Status = JobItemOperationResultFileStatus_e.Succeeded
    Catch
        resFile.Status = JobItemOperationResultFileStatus_e.Failed
    End Try
Next

//Report operation issue
operation.ReportIssue("Something went wrong", JobItemIssueType_e.Error);

try
{
    //TODO: perform operation
}
catch (Exception ex)
{
    //Reporting the user error
    operation.ReportIssue(ex.ParseUserError("Unknown error"), JobItemIssueType_e.Error);
}

//Adds the trace message
operation.Logger.Log("Starting the process", XCad.Base.Enums.LoggerMessageSeverity_e.Information);

//Adds the log message into the log window
operation.Log("Outputting the file");

//Sets the user result to be displayed in the report grid
operation.SetResult(50);

'Report operation issue
operation.ReportIssue("Something went wrong", JobItemIssueType_e.Error)

'TODO: perform operation
Try
Catch ex As Exception
    'Reporting the user error
    operation.ReportIssue(ex.ParseUserError("Unknown error"), JobItemIssueType_e.Error)
End Try

'Adds the trace message
operation.Logger.Log("Starting the process", Base.Enums.LoggerMessageSeverity_e.Information)

'Adds the log message into the log window
operation.Log("Outputting the file")

'Sets the user result to be displayed in the report grid
operation.SetResult(50)

if (!(doc is IXDrawing)) 
{
    throw new UserException("Only drawing documents are supported");
}

If Not (TypeOf doc Is IXDrawing) Then
    Throw New UserException("Only drawing documents are supported")
End If