Scripts Classes Reference

Organize reusable classes for scripts.

Reference → Modules → Scripts → UI → Code Editor | Classes | Expressions | Monitor | References | Tasks 

• 1. Creating ScriptClasses

     Access Scripts → Classes

     Click the plus icon to create a new class. Three options are available:

     1. Class with Methods - Standard reusable code library
     2. Full Namespace - Advanced .NET namespace (Visual Studio-like)
     3. MCP Tool - AI model integration via Model Context Protocol

     Configuration Properties

     Property	Description
     Name	Class identifier used in code references
     Code	Programming language (C#, Python, VB.NET)
     Domain	Execution location: Server (global) or Client (local)
     ClassContent	Type: Methods or Namespace
     Edit Security	Permission level required to modify
     Build Order	Compilation sequence when multiple classes exist
     Build Status	Green check (success) or Red X (errors)
     Build Errors	Compilation error details
     Description	Documentation for the class purpose

     ---

     Code Structure Requirements

     CRITICAL: Do not include class declarations or namespace definitions in ScriptClasses

     When creating a ScriptClass with Methods or MCP Tool:

     • DO NOT include: public class MyClass { }
     • DO NOT include: namespace MyNamespace { }
     • DO NOT include: using statements directly in code
     • DO include: Method definitions only
     • DO use: Namespace Declarations button for using statements

     The platform automatically wraps your code in the appropriate class structure using the Name from the configuration table.

     Correct ScriptClass Format

     csharp

     // Methods directly - NO class wrapper, NO using statements
     public string ProcessData(double value)
     {
         return $"Processed: {value:F2}";
     }
     
     public int Calculate(int a, int b)
     {
         return a + b;
     }

     Adding Namespace Declarations

     To add using statements (C#) or Import statements (VB.NET):

     1. Open the Code Editor
     2. Click the Namespace Declarations button in toolbar
     3. Add required namespaces in the dialog
     4. Never put using statements directly in the code

     ---

     ScriptClass Types

     1. Class with Methods (Standard)

     Most common type for reusable code:

     • Platform manages as static object
     • Automatic exception handling
     • No instantiation required
     • Access via: @Script.Class.ClassName.MethodName()

     Example:

     csharp

     // In ScriptClass named "Calculations"
     public double CalculateEfficiency(double actual, double target)
     {
         if (target == 0) return 0;
         return (actual / target) * 100;
     }
     
     // Usage anywhere in solution:
     // double eff = @Script.Class.Calculations.CalculateEfficiency(95, 100);

     2. MCP Tool

     Special class type for AI integration:

     • Exposes methods to external Language Models
     • Requires decorator attributes
     • Methods without decorators behave as regular methods
     • Available in all editions including EdgeConnect

     Example:

     csharp

     [MCPMethod(Description = "Get tank level")]
     public double GetTankLevel(
         [MCPParameter(Description = "Tank ID")] string tankId)
     {
         return @Tag[$"Tank_{tankId}_Level"];
     }

     3. Full Namespace (Advanced)

     Advanced Feature Warning: Full Namespace is for experienced developers only. Most applications should use standard Class with Methods. This option requires manual object instantiation and exception handling like Visual Studio development.

     Complete .NET namespace implementation:

     • Requires full namespace and class declarations
     • Manual object instantiation required
     • No automatic exception protection
     • Full control over implementation

     Example:

     csharp

     namespace MyCompany.Utilities
     {
         public class AdvancedProcessor
         {
             private int counter = 0;
             
             public void Process()
             {
                 // Implementation
             }
         }
     }
     
     // Usage requires instantiation:
     // var processor = new MyCompany.Utilities.AdvancedProcessor();
     // processor.Process();

     ---

     Built-in Classes

     All solutions include:

     ServerMain

     Global methods library executed on server:

     • Available to all server-side scripts
     • Runs in TServer main thread
     • Pre-instantiated by platform
     • Special entry points for server initialization

     ServerMain has special integration with TServer process. Additional documentation on advanced ServerMain features will be provided in future updates.

     ClientMain

     Local methods library executed on each client:

     • Runs independently per client
     • Pre-instantiated for each client connection
     • Access to local display context
     • Ideal for UI-specific operations

     ---

     Library Import/Export

     ScriptClasses can be shared between solutions using the Library feature:

     Export to Library

     1. Select ScriptClass in table
     2. Click Export to Library
     3. Class is saved to central Library.dbsln repository

     Import from Library

     1. When creating new class, select Get from Library
     2. Browse available classes in Library.dbsln
     3. Select and import desired class

     The Library serves as a centralized repository for reusable components across all your solutions.

     ---

     Cross-Language Interoperability

     FrameworX enables calling between languages transparently:

     csharp

     // C# ScriptClass calling Python method
     double result = @Script.Class.PythonClass.calculate_value(10, 20);

     python

     # Python ScriptClass calling C# method
     efficiency = TK.Script.Class.CSharpClass.CalculateEfficiency(95.5, 100.0)

     For detailed Python/.NET integration including type conversions and limitations, see [Python.NET Integration (Reference)]

     ---

     Accessing Solution Objects

     ScriptClasses can directly access all solution namespaces:

     csharp

     public void UpdateProduction()
     {
         // Access Tags
         double rate = @Tag.ProductionRate;
         
         // Access Alarms  
         bool hasAlarm = @Alarm.HasActive("Line1");
         
         // Access Historian
         var history = @Historian.GetValues("Temperature", 100);
         
         // Access other Script Classes
         var result = @Script.Class.OtherClass.Method();
         
         // Access Script Tasks
         @Script.Task.MyTask.Run();
     }

     ---

     External References

     To use external .NET assemblies:

     1. Add Assembly Reference
        • Go to Scripts → References
        • Add external DLL location
        • See [Scripts References (Reference)] for details
     2. Add Namespace Declaration
        • Open Code Editor
        • Click Namespace Declarations button
        • Add namespaces from referenced assembly
     3. Use in Code
        • Call methods from external assembly
        • No using statements in code itself

     ---

     Compilation and Build Order

     Build Process

     1. Classes compile in Build Order sequence (lowest first)
     2. Cached compilation for unchanged classes
     3. Full rebuild clears cache

     Circular References

     Avoid circular references between classes. While not blocked by the system, they cause:

     • Compilation failures during full builds
     • Maintenance difficulties
     • Debugging complications

     If circular references exist, temporarily comment one reference to allow compilation.

     ---

     Best Practices Checklist 

     • Use descriptive names - Class and method names should indicate purpose
     • Add XML comments - Document methods for IntelliSense
     • Handle exceptions - Even with automatic protection, validate inputs
     • Avoid circular references - Design clear dependency hierarchy
     • Use standard classes - Only use Full Namespace when absolutely necessary
     • Test incrementally - Verify Build Status after each change
     • Use Namespace Declarations - Never put using statements in code

     ---

     Troubleshooting

     Red X Build Status

     • Double-click to see specific errors
     • Check for missing semicolons or braces
     • Verify all referenced tags/objects exist

     Methods not accessible

     • Confirm Build Status is green
     • Check Domain (Server/Client) matches usage location
     • Verify syntax: @Script.Class.ClassName.MethodName()

     Class wrapper errors

     • Remove any public class declarations
     • Remove namespace definitions (unless Full Namespace type)
     • Remove using statements from code (use Namespace Declarations button)

     Cannot find external types

     • Add assembly reference in Scripts → References
     • Add namespace via Namespace Declarations button
     • Verify DLL compatibility with target framework

In this section...