Scripting
What’s the impact of changing my “public class QAction” to “public static class QAction”?
If there’s an impact, what’s the reason behind this?
Automation
What’s the impact of changing my “public class Script” to “public static class Script”?
If there’s an impact, what’s the reason behind this?
The main thing to be aware is that static fields and properties are shared across either the entire SLAutomation or SLScripting engine. For example, static fields and properties are shared across multiple runs of the same script or QAction and get remembered as long as the DataMiner Agent or hosting process doesn’t restart. Be aware that locking is needed when accessing the same static data structures from multiple simultaneously running automation scripts/QActions.
Marking a class as static indicates that it can only contain static fields, properties and methods and that no instance objects can be created for it. The compiler will complain if you would try to do add non-static fields/properties/methods.
The main difference in behavior is with the entry point into an automation script or QAction (“Run” method).
- If the Run method is marked as static, an automation script or QAction execution will not create an object instance of the class, and only static data can be accesses from within the script/QAction.
- If the Run method is non-static, an instance object will be created either per automation script run or per element run (for QActions). The script can then access both instance-level fields/properties from this instance, but can also access static fields if these are defined.
The main difference between Automation scripts and QActions is that for QActions, the instance object is re-used across QAction invocations for the same element while for Automation scripts every run creates a new temporary instance object.
I would advise to mark your class as static if you want to use the static Run method, as any instance fields/methods/properties won’t make much sense in that scenario.
To answer to the Scripting part of the question:
Marking the class as static indicates that all members of the class must be static. When executing a QAction, DataMiner will look if the method is marked as static. If it’s static then no instance will be created, even if the class itself is not marked as static.
Using static classes means that this class object and its static fields are shared across all the elements running on the same DMA, in the same SLScripting process. This means that element A and element B of the same protocol driver in that case have access to the same static fields in their QAction. The application domain keeps track of static objects in the managed heap. These objects stay in there as long as the DMA is active and survives the restart of an element. When using DIS inject, the element uses a static DIS object. After the DIS inject, the element will use again the original static object.
Using classes without the static keyword means that for every element QAction class there will be an instance object created. These will then have no access to the fields of other elements of the same driver running in the same SLScripting process. The instance object will not survive an element restart and will eventually be cleaned up by the garbage collector when that walks over the managed heap. When using DIS inject, the element uses a new created instance object. After DIS inject, the element will use again a new created instance object instead of the one that was used before the DIS inject. Keep this in mind when implementing a QAction that this situation could occur.
To summarize:
-If you have no fields in the QAction class then use the static keyword, there is no need to create multiple instance objects of the QAction class. If there are 100 elements on the DMA then 100 instance objects are created when not using the static keyword. If static keyword is used then you only have one static class object in memory.
-If you have static fields in the QAction class then be aware that the static keyword means that the fields are shared across elements on the same DMA: one element could overwrite the other one, locking might be needed. The data will survive an element restart. If you’re 100% sure that this will be the only element of this driver in the DMA (e.g. a manager driver) or have taken the data sharing and locking in account then you can use the static keyword. Without the static keyword this is more safe, every element will have access to only its own set of data.