Page History

Extend solutions with Python, C# and VB.NET logic.

Reference → Scripts| Tutorial | How-to Guide | Reference

Scripts Module (Reference) provides automation and business logic capabilities through classes, tasks, expressions, and integrated development tools. It enables:

Reusable code libraries via Script Classes
Event-driven automation through Script Tasks
Lightweight calculations using Script Expressions
External integration with Script References
Development productivity with integrated Code Editor

Scripts execute primarily server-side for web compatibility, with optional client-side execution for WPF-only deployments.

Table of Contents
maxLevel 2
minLevel 2
indent 10px
exclude Steps
style none

Module Components

Configuration Sections

Section	Path	Purpose
Classes	Scripts → Classes	Reusable methods and functions
Tasks	Scripts → Tasks	Event-driven automation logic
Expressions	Scripts → Expressions	Simple calculations and method calls
References	Scripts → References	External DLL integration
Code Editor	Scripts → Code Editor	Integrated development environment

Configuration Workflow

Action	Where	Purpose
Create Classes	Scripts → Classes	Build reusable function libraries
Define Tasks	Scripts → Tasks	Implement automation logic
Add Expressions	Scripts → Expressions	Configure simple calculations
Import References	Scripts → References	Add external assemblies
Edit Code	Scripts → Code Editor	Write and debug scripts

Runtime Architecture

Execution Context

Default Configuration:

Server-side: Tasks and expressions run on TServer.exe
Client-side: Only Display Code Behind executes locally
Script Classes: Available to both server and client

Web Compatibility:

Client-side tasks disabled by default for HTML5 support
Enable in Solution → Settings for WPF-only deployments

Script Namespace

Access script objects at runtime:

csharp

// Access Script Classes
var result = @Script.Class.ClassName.Method();

// Monitor Script Tasks
int count = @Script.Task.TaskName.ExecutionCount;
TimeSpan cpu = @Script.Task.TaskName.LastCPUTime;

Performance Considerations

For complex or large solutions requiring optimization: → See [Script Engine (Reference)] for deep technical details

Key Concepts

Script Classes

Repository of reusable methods
Automatic static instantiation
Cross-language support (C#/VB.NET/Python)
Three types: Methods, MCP Tools, Full Namespace

→ [Script Classes (Reference)]

Script Tasks

Event or time-triggered execution
Independent threading model
Automatic exception protection
Built-in startup/shutdown tasks

→ [Script Tasks (Reference)]

Script Expressions

Single-line VB.NET statements
Automatic change detection
Ideal for simple calculations
Reduces need for one-line tasks

→ [Script Expressions (Reference)]

Script References

External DLL integration
Framework compatibility management
Namespace declaration system
Path macro support

→ [Script References (Reference)]

Code Editor

Multi-language support
IntelliSense with solution objects
Integrated debugging
Language conversion

→ [Code Editor (Reference)]

Best Practices

Code Organization

Use Classes for reusable logic
Use Tasks for complex automation
Use Expressions for simple calculations
Name consistently with descriptive identifiers

Performance

Server-side by default for web compatibility
Monitor execution via diagnostic properties
Build before deployment to ensure compilation
Profile large solutions using Script Engine diagnostics

Development

Format code for readability
Handle exceptions even with automatic protection
Test incrementally with build verification
Document purpose in descriptions

Library Management

Use References for external DLLs
Manage namespaces via declaration dialog
Version control external dependencies
Test compatibility with target framework

Troubleshooting

Build Issues

Build Errors:

Check BuildStatus property
Review BuildErrors details
Verify referenced objects exist
Ensure correct language syntax

Circular Dependencies:

Review build order
Temporarily comment references
Restructure class dependencies

Execution Problems

Tasks Not Running:

Verify InitialState enabled
Check trigger configuration
Review domain settings
Monitor execution count

Performance Issues:

Check LastCPUTime metrics
Review execution frequency
Optimize synchronization
Consider pre-loading strategy

Reference Issues

DLL Not Loading:

Verify .NET framework compatibility
Check path macros
Restart after DLL updates
Review resolved status

Namespace Conflicts:

Use declaration dialog
Check default namespaces
Verify reference order

Debugging

Breakpoints Not Hit:

Enable debug information
Attach debugger to process
Verify code has compiled
Check execution path

Variable Inspection:

Use @ prefix for solution objects
PropertyWatch for real-time values
Watch window during breaks

Common Issues

Language Conversion

C# to VB.NET usually succeeds
VB.NET to C# may need type casting fixes
One-time migration recommended

Client-Side Limitations

Disabled by default for web
Only WPF clients support
Server-side preferred approach

Incremental Compilation

Automatic background process
Cache invalidation on changes
Full build before production

Excerpt Include

	Scripts Module
	Scripts Module
nopanel	true

In this section...

Page Tree

root	@parent

HTML

<style>
.text-span-6 {
    background-image: linear-gradient(99deg, rgba(170, 163, 239, .5), rgba(125, 203, 207, .5));
    border-radius: 50px;
    padding-left: 15px;
    padding-right: 15px;
}

#title-text {
display: none;
}

.panelgradient {
    background-image: linear-gradient(180deg, #d5def0, whitesmoke);
    border-radius: 8px;
    flex-direction: column;
    justify-content: center;
    align-items: center;
    padding: 4rem;
    display: flex;
    position: relative;
}

</style>


<div class ="panelgradient">

<h1 style="text-align: center;">Scripts <br> (Tasks and Classes)</h1>

</div>

Introduction to the Scripts Module

Image Removed

The Scripts Module supports multiple programming languages, including C#, VB.NET, Python, and JavaScript, enabling the creation of high-performance server-side and client-side scripts in Display Code-Behind. Its built-in code editor streamlines development with automated translation between C# and VB.NET and provides access to all .NET Framework classes available in Visual Studio. The module simplifies distributed application development using server or client domains and ensures high performance through custom code compilation. Additionally, it enhances graphical displays with Display Code-Behind functions and offers debugging tools for quick identification and resolution of coding issues.

On this page:

Table of Contents

maxLevel	3
minLevel	2
style	none

The Scripts Module allows:

Multi-Threaded Task Execution
Event-Driven Actions
Library Creation for Methods and Classes
Intermixing C#, VB.NET and Python classes.
Integration with Third-Party Libraries.

Image Removed

Key Concepts and Terms

The Scripts Module manages and executes user-defined scripts for automation and process control.

ScriptTask

Defines code that executes in reaction to an event (trigger) or periodically at specified intervals.

ScriptClass

A library of functions and methods that can be used in Script Tasks, Expressions, or from the Code Behind on graphical Displays.

ScriptExpression

One line of code in response to an event, when the entire script isn't necessary.

Script References

External DLLs included for a script or display code compilation.

Understanding the Scripts Module

Module Highlights

Built-in Code Editor: Our code editor supports C#, VB.NET, JavaScript, and Python languages.
Server and Client Domains: Create scripts that execute on the server for global reach or on the client side for local reach.
Events and Scheduling: Tasks and expressions can be triggered by date, time, condition, calendar, tag change, or interval. Execution is distributed among processes, each running in its own application domain, isolated from the real-time database, ensuring maximum system security and performance.
Object Orientation and Solution Object: All solution objects, including tags, datasets, alarms, devices, and communication statuses, are immediately accessible via IntelliSense as native .NET objects. No temporary tags or function calls are required. With a single command, move data from tags to .NET objects and external data tables.
Configure Your Python Interpreter: The Scripts Module delivers exceptional scripting capabilities across various programming languages with seamless integration of Python. You can configure any version of the Python interpreter for each project.

Configuring the Scripts Module

Configuration Workflow

Scripts Module configuration workflow

Action

Where

Comments

Manage ScriptClasses

Scripts / Classes

Create or Import you function Library. Learn more at Scripts Classes.

Manage ScriptTasks

Scripts / Tasks

Create or Import Tasks. Learn more at Scripts Tasks.

Manage ScriptExpressions

Scripts / Expressions

For simple event or time driven actions, use Expressions. Learn more at Scripts Expressions.

Manage Script References

Scripts / References.

If you code required their party libraries, include the references. Learn more at Scripts References.

Working with the Scripts Module

Runtime Execution

The key concept to be aware of regarding the execution of the tasks and expressions defined in the Script Module is that they execute on the server computer.

Only the CodeBehind of the displays is executed on each client computer. The script classes can be consumed by both server and client stations.

Current solutions are prioritizing user interfaces that are portable, meaning the exact same drawing and display configuration can run as a WPF Windows Rich Client or as a web HTML5 page inside a browser. If you intend to run the graphical interface only on WPF Windows and not on web pages, it is possible to enable this in Solution / Settings to allow tasks and expressions to run on the client side.

For complex solutions or very large solutions, it's useful to get a deeper understanding of the Module execution process. Read more at Module Script Execution if that is your case.

Script Runtime Attributes

The Namespace Script is the entry point for all objects related to the Scripts module.

The Script.Class object lists all configured tables and its runtime properties. The Script.Task object lists all configured database connections and their runtime properties.

Examples:

Script Task Properties

Property

Type

Description

Script.Task.Task1.ExecutionCount

Integer

Number of times the Script Task <Task1> was executed.

Script.Task.Task1.LastCPUTime

TimeSpan

The Amount of CPU used the last time the Script Task Task1 was executed.

→ Read more about Objects and Namespaces.

AnchorBestPracticesBestPracticesBest Practices and Troubleshooting

Best Practices and Recommendations

Code Formatting: Use the 'Format' feature of the editor for more readability.
Naming Convention: Use a coherent and descriptive naming convention for tasks.
Task Domain: Select the appropriate domain for each task, considering whether the task is more suitable for client-side or server-side execution. Remember, Client-Side Tasks only applicable to RichClients
Reusable Code: Use reusable code by creating classes that encapsulate functionalities for use in various parts of the project.
Library Management: Manage libraries and external components effectively to avoid conflicts and compatibility issues.
Code Consistency: Maintain code consistency by following best practices and coding conventions.
Build Before Deployment: Always perform a build operation before deploying a project in a production environment to ensure all scripts are correct and up to date.

Troubleshooting and Common Issues

The Scripts module may encounter some issues in its operation. Here are some common issues and their troubleshooting:

Build Errors and Warnings: Make sure to check the 'BuildStatus' and 'BuildErrors' tabs to identify and address errors and warnings that arise during the build.
Code Language: If you change the code language in the code editor, confirm that the code has been correctly converted to the selected language.
Build Order: Ensure that the build order of the classes is set up correctly to avoid circular dependencies or initialization issues.
Domain Selection: Ensure that the domain is selected correctly (Client or Server) based on the needs of your project.
Reference Issues: Make sure that all external references are configured correctly and that there are no compatibility issues or conflicts in the Code Editor.
Code Formatting: Use the 'Format' feature of the editor for more readability.
Incremental Compilation Issues: Monitor the incremental compilation process to identify and resolve potential issues that may arise.
Debugger Setup: Ensure that the debugger setup is correct to allow effective code debugging.
Breakpoints and Watch Variables: Use breakpoints and watch variables effectively to identify and resolve issues.

In this section:

Page TreerootV10:@selfspacesV10

Page tree

Page History

Versions Compared

Old Version 2

New Version Current

Key

Table of ContentsmaxLevel2minLevel2indent10pxexcludeStepsstylenone

Module Components

Configuration Sections

Configuration Workflow

Runtime Architecture

Execution Context

Script Namespace

Performance Considerations

Key Concepts

Script Classes

Script Tasks

Script Expressions

Script References

Code Editor

Best Practices

Code Organization

Performance

Development

Library Management

Troubleshooting

Build Issues

Execution Problems

Reference Issues

Debugging

Common Issues

Language Conversion

Client-Side Limitations

Incremental Compilation

In this section...

Introduction to the Scripts Module

Image Removed

Key Concepts and Terms

ScriptTask

ScriptClass

ScriptExpression

Script References

Understanding the Scripts Module

Configuring the Scripts Module

Configuration Workflow

Working with the Scripts Module

Runtime Execution

Script Runtime Attributes

Best Practices and Recommendations

Troubleshooting and Common Issues

Table of Contents
maxLevel 2
minLevel 2
indent 10px
exclude Steps
style none