@aryacode/dsh-engineering 0.5.0 → 0.7.0

package/vendor/optix/netlogic/pages/threading.md

@@ -0,0 +1,236 @@
+# FT Optix Runtime – Threading Model
+
+## Overview
+
+The FT Optix Runtime is built around a **shared, priority-based thread pool** combined with an **affinity-based task serializer**. This design allows many independent subsystems to execute concurrently without requiring each one to own a dedicated OS thread, while still giving every behavior object a strong single-threaded execution guarantee.
+
+Understanding this model is important when reasoning about the relationship between **CPU clock speed** and **CPU core count** on overall application performance.
+
+
+
+## Core Thread Pools
+
+### Main dispatch pool
+
+At startup, the runtime creates one shared thread pool containing **one worker thread per logical CPU** (determined via `std::thread::hardware_concurrency()`). On a 4-core/8-thread CPU this gives 8 workers; on a 32-core/64-thread server it gives 64.
+
+All asynchronous callbacks for behavior objects - variable change notifications, OPC UA events, and user-defined dispatch calls - are served from this single pool.
+
+The pool uses a six-level priority queue, so time-sensitive work is always promoted ahead of background tasks:
+
+| Priority | Intended use |
+|---|---|
+| Blocking | Tasks that must start immediately to unblock a caller |
+| Highest | Critical-path control actions |
+| High | Time-sensitive HMI updates |
+| Normal | Default for most dispatched work |
+| Low | Background data logging, analytics |
+| Lowest | Maintenance sweeps |
+
+### Timer pool
+
+One-shot and periodic timers are managed by a separate timer subsystem backed by its own **fixed-size thread pool** (independent of the main dispatch pool). This ensures that a slow or blocked timer callback cannot starve other dispatched work, and vice versa.
+
+Timers are added programmatically and are represented by a RAII handle: dropping the handle cancels the timer. A blocking removal API is also available that waits for any currently executing callback to finish before returning.
+
+## Affinity-Based Dispatch
+
+### The affinity concept
+
+Every behavior object in the runtime is assigned a unique numeric **affinity ID** at construction time. The task scheduler guarantees that **no two tasks sharing the same affinity ID ever run concurrently**, regardless of how many pool threads are available.
+
+This is the primary concurrency safety mechanism in the runtime. Behavior code can access its own state without locks because only one task bearing its affinity ID will ever run at a time. Mutexes are only required when data is shared *across* affinity boundaries.
+
+### Task lifecycle
+
+```
+  Trigger (variable change / OPC UA event / timer expiry)
+           │
+           ▼
+    Dispatch(callback, affinityId)
+           │
+      ┌────┴─────┐
+      │ Is the   │ Yes ──► park task until current task for
+      │ affinity │         this affinity completes
+      │ busy?    │
+      └────┬─────┘
+           │ No
+           ▼
+    Mark affinity as "in-flight"
+           │
+           ▼
+    Submit to thread pool ──► picked up by an idle worker thread
+           │
+           ▼
+    Execute callback on pool thread
+           │
+           ▼
+    On completion: promote next parked task for this affinity (if any)
+```
+
+### Shutdown guards
+
+Three lifecycle guards coordinate ordered shutdown of a behavior:
+
+| Guard | Effect |
+|---|---|
+| Suspend dispatch | New tasks queue up; the current in-flight task runs to completion |
+| Suspend on stop | Same, but auto-resumes when the guard scope exits |
+| Terminate on stop | All queued tasks for this affinity are abandoned when the guard scope exits |
+
+## Per-Subsystem Dedicated Threads
+
+Beyond the shared pool, several subsystems own their own dedicated OS thread for specialized I/O serialization:
+
+| Subsystem | Thread count | Purpose |
+|---|---|---|
+| Communication driver scheduler | One per configured driver station | Runs timed poll tasks in priority order (read/write priority levels); also handles on-demand requests enqueued from other threads |
+| Persistent store I/O | One per store node | Serializes all database reads and writes; exceptions propagate back to the calling thread synchronously |
+| UI rendering queue | One | Batch consumer queue for layout and rendering operations that must not block OPC UA callbacks |
+| Write batching | One | Collects write values from any thread, batches them, and forwards them on its own thread to reduce protocol round-trips |
+| Store-and-forward retry | Timer-driven | Uses the timer subsystem for flush and retry intervals; no permanently blocked thread |
+
+## Communication Driver Threading
+
+Each configured **driver station** runs its own scheduler thread. This thread:
+
+- Maintains a sorted queue of tasks keyed by **priority level** (Read / Write) and **next execution time**.
+- Pulls the next due task, executes it, then reschedules it if it is periodic (configured with a period in milliseconds).
+- Accepts on-demand tasks (single-execution jobs) from any thread via an enqueue API; these are prioritized above or below cyclic poll tasks depending on their priority level.
+- Transitions through a communication state machine (connecting → connected → error → reconnecting) independently of any other station's thread.
+
+Because each station has its own thread, **N configured stations require N dedicated threads** regardless of pool size. Stations are fully isolated: a network hang on station A does not affect the scheduler thread of station B.
+
+### Threads vs CPU cores - over-subscription
+
+Having more driver stations than CPU cores is normal and supported. A scheduler thread spends the vast majority of its time **sleeping** (blocked on a timed wait until the next task is due). Sleeping threads do not consume a CPU slot - the OS only schedules them onto a core when they have actual work to do. Twenty stations on an 8-core machine is a common and well-functioning configuration.
+
+Over-subscription only becomes noticeable when **many stations have work ready at the same instant**:
+
+- If N stations all have a short-period poll task that fires simultaneously, and N is greater than the number of logical CPUs, the OS will time-slice. Some stations will be delayed by one OS scheduling quantum while waiting for a free CPU slot.
+- The magnitude of this delay is typically in the range of a few hundred microseconds to a few milliseconds, depending on OS and system load.
+- This introduces **jitter** into the actual poll period - the configured period is a minimum interval, not a hard real-time guarantee.
+
+**When this matters in practice:**
+
+| Scenario | Impact |
+|---|---|
+| Poll periods ≥ 100 ms (typical SCADA/HMI) | Negligible - a 1–2 ms jitter on a 500 ms cycle is imperceptible |
+| Poll periods 10–100 ms with many stations | May cause occasional late scans under load; monitor with task execution counters |
+| Poll periods < 10 ms with many stations | Requires careful sizing; use more physical cores or reduce the number of concurrently active stations |
+
+**Mitigations if over-subscription causes issues:**
+
+- Increase the number of physical CPU cores.
+- Stagger station start times to spread wake-up patterns naturally (stations started at different times will tend to drift into different scheduling slots).
+- Increase poll periods where sub-100 ms scanning is not strictly required.
+- Run the runtime process at elevated OS scheduling priority to reduce competition from other processes on the same machine.
+
+## NetLogic Execution Model
+
+### Default execution (short-lived operations)
+
+C# NetLogic methods (`Start()`, UA method callbacks) execute on a **pool thread from the main dispatch pool**, within the affinity context of the owning NetLogic node. This means:
+
+- `Start()` and method callbacks are serialized with respect to that node - no locks are needed for node-local state.
+- A `Start()` or method callback that runs longer than **2 seconds** triggers a runtime warning in the log.
+- Any computation or I/O that may take longer must be explicitly offloaded to a `LongRunningTask`.
+
+### Long-running tasks
+
+`LongRunningTask` allocates a **dedicated OS thread** for the duration of the task (using .NET's `TaskCreationOptions.LongRunning`). This prevents slow user code from occupying a shared pool thread and impacting other nodes.
+
+```csharp
+public override void Start()
+{
+    longTask = new LongRunningTask(RunSlowOperation, LogicObject);
+    longTask.Start();
+}
+
+private void RunSlowOperation(LongRunningTask task)
+{
+    // Runs on its own dedicated OS thread.
+    // Use task.IsCancellationRequested to cooperate with Stop().
+    while (!task.IsCancellationRequested)
+    {
+        // ... polling loop, database query, external API call, etc.
+    }
+}
+
+public override void Stop()
+{
+    longTask?.Dispose(); // requests cancellation and waits for the thread to exit
+}
+```
+
+**Important:** `LongRunningTask` instances must always be disposed in `Stop()`. Failing to do so will leave an OS thread running after the node is stopped.
+
+## Thread Count at a Glance
+
+```
+Main dispatch pool:      hardware_concurrency threads  (all behavior callbacks)
+Comm driver scheduler:   1 thread per station          (protocol polling & writes)
+Persistent store I/O:    1 thread per store node       (DB serialization)
+UI rendering queue:      1 thread                      (layout / paint batching)
+Write batching:          1 thread                      (output batching)
+LongRunningTask (.NET):  1 thread per active instance  (user long-running logic)
+```
+
+## How the Application Benefits from More CPU Threads vs Higher Clock Speed
+
+### Workloads that scale with more CPU cores
+
+Because the main dispatch pool is sized to `hardware_concurrency`, adding more logical CPUs directly increases the number of behavior callbacks, timer tasks, and OPC UA events that can execute simultaneously.
+
+| Workload | Why more cores help |
+|---|---|
+| **Many independent HMI nodes with data subscriptions** | Each affinity can be scheduled on a different thread. With 100 nodes and 8 cores, up to 8 nodes update in parallel; with 16 cores, up to 16 do. |
+| **Multiple communication driver stations** | Each station has its own dedicated scheduler thread. More cores prevent those threads from time-sharing with pool workers. |
+| **Multiple store nodes** | Each store node has its own I/O thread. Concurrent database operations proceed in parallel. |
+| **Many active `LongRunningTask` instances** | Each occupies a dedicated OS thread. More physical cores allow more of them to run truly in parallel. |
+| **High-frequency periodic timers** | The timer pool has a fixed number of threads. If many timers fire at the same millisecond, more idle cores prevent queuing delays. |
+
+**Rule of thumb:** if the application has more independent behavior objects, driver stations, or long-running tasks than the CPU has threads, adding more cores will improve throughput approximately proportionally - until another bottleneck (network, storage, database latency) takes over.
+
+### Workloads that scale with higher clock speed
+
+Some execution paths are natively serial and cannot be parallelized at the dispatch level:
+
+| Workload | Why higher clock helps |
+|---|---|
+| **Single "hot" behavior receiving events faster than it can process them** | Clock speed directly reduces per-callback latency. Task queue depth stays near zero. |
+| **NetLogic `Start()` or method with heavy computation** | These run sequentially within their affinity. A computationally intensive method benefits from more MHz, not more cores. |
+| **Communication driver scan cycle** | Each station runs on a single thread. Heavy protocol decoding or tag-mapping logic is bounded by single-thread performance. |
+| **Persistent store transactions** | One thread per store node. Reducing query or write time (clock speed, fast SSD) reduces transaction latency. |
+| **OPC UA Server session management** | Session-level state is managed on dedicated internal threads. Reducing per-session processing time allows more concurrent clients without queuing. |
+| **Low-latency periodic timers (< 10 ms)** | Short-period timers are sensitive to OS scheduling jitter and CPU cache performance, both of which improve with higher base clock. |
+
+### Practical guidance
+
+| Scenario | Recommended focus |
+|---|---|
+| Faster HMI screen load and rendering | Higher clock speed |
+| Multiple HMI sessions (WebPresentationEngine clients) | More cores but with some limitations (see the [hot-path issue](#the-hot-path-issue)) |
+| Many communication driver stations | More cores (each needs its own thread) |
+| Heavy per-event computation in NetLogic | Higher clock speed |
+| Fast scan-rate polling (1–10 ms) | Higher clock + real-time OS configuration |
+| Large data logger write throughput | More cores AND fast storage I/O |
+| Typical mixed HMI application | 4–8 fast cores is the sweet spot; beyond ~8 cores gives diminishing returns unless the project has a very large number of independent subsystems (see the [hot-path issue](#the-hot-path-issue)) |
+
+### The hot-path issue
+
+A significant benefit of a multi-core CPU is on applications having many independent modules (HMI sessions, driver stations, data stores, long-running tasks). In these cases, adding cores increases throughput as the different modules are assigned to different threads. 
+
+If multiple modules are contending for the same set of items (same PLC tag, same store, etc.), then adding cores will not help, and the application will be limited by the single-threaded performance of the hot path.
+
+### Hyper-Threading / SMT
+
+The main pool creates one thread per **logical** CPU. On a system with Hyper-Threading, two logical threads share one physical core's execution units. Because most runtime pool tasks involve a mix of memory accesses and computation, Hyper-Threading typically provides a 20–40 % throughput improvement over the equivalent physical core count without it. However, Hyper-Threading does **not** reduce latency for a single hot path - only additional physical cores do.
+
+## Key Design Principles
+
+1. **One main pool, many affinities.** All behavior callbacks share the same thread pool. Isolation is achieved through affinity serialization, not through private threads per behavior.
+2. **Timer callbacks are isolated from dispatch callbacks.** A blocking timer never starves the main pool.
+3. **Communication drivers are fully isolated from each other.** Each station has its own scheduler thread; a network fault on one station does not affect others.
+4. **Long user code must be explicit.** NetLogic that takes more than a few milliseconds must be moved to a `LongRunningTask`. Short callbacks keep the pool responsive for all other nodes.
+5. **Hardware concurrency drives pool size.** Adding CPU cores directly translates to pool thread count with no configuration change required.

package/vendor/optix/netlogic/pages/translations.md

@@ -0,0 +1,417 @@
+# Translations
+
+## Assign a translation key to a Text property
+
+Please note: `myKey` should already exist in the TranslationDictionary
+
+```csharp
+// Create a new label
+Label myLabel = InformationModel.Make<Label>("MyLabelName");
+// Create a new LocalizedText with a specific Key (that should exist in the LocalizationDictionary)
+myLabel.LocalizedText = new LocalizedText(myLabel.NodeId.NamespaceIndex, "myKey1");
+// Add the label to the project
+Owner.Add(myLabel);
+```
+
+## Read the translation key of a Text property
+
+```csharp
+// Get the LocalizedText variable from the Label
+string myKey = myLabel.LocalizedText.TextId
+```
+
+```csharp
+// Alternative way (same result)
+string myKey = ((LocalizedText)myVariable.Value).TextId
+```
+
+## Read the translation content for a specific key
+
+```csharp
+// Create a new temporary localized text to read the key value from the dictionary
+LocalizedText alarmKey = new LocalizedText(LogicObject.NodeId.NamespaceIndex, "Alarm_TL_Key");
+// Get the text value from the current language
+string alarmMessage = InformationModel.LookupTranslation(alarmKey).Text;
+```
+
+## Adding a description to a variable
+
+```csharp
+// Set the description of an object to a localized text
+variable.Description = new LocalizedText(Project.Current.NodeId.NamespaceIndex, "descriptionTextId");
+```
+
+## Create a dictionary
+
+Dictionary is a variable with dataType OpcUa.String and variableType FTOptix.Core.LocalizationDictionary, values are stored in a bidimensional array of string
+
+```csharp
+private void StuffMakeNewDictionary(string browseName, string[]languages, IUANode dictionaryOwner) 
+{
+    if (dictionaryOwner == null || languages.Length <= 0 || string.IsNullOrEmpty(browseName))
+        return;
+    if (languages[0] != "")
+    {
+        // The first column needs to be empty as it's the keys list
+        string[] firstColumnEmpty = new string[1] {""};
+        // Add the languages to the other columns
+        languages = firstColumnEmpty.Concat(languages).ToArray();
+    }
+    List<string> languageVerifiedToAdd = new List<string>();
+    foreach (string language in languages) 
+    {
+        try
+        {
+            if (CultureInfo.GetCultureInfo(language, false) != null)
+                languageVerifiedToAdd.Add(language);
+        }
+        catch 
+        {  
+            // In case of culture identifier is not valid, skip to add to dictionary          
+        }
+    }
+    string[,] newDictionaryValues = new string[1, languageVerifiedToAdd.Count];
+    for (int i = 0; i < languageVerifiedToAdd.Count; i++) 
+    {
+        newDictionaryValues[0,i] = languageVerifiedToAdd[i];
+    }
+    // Create the new dictionary
+    IUAVariable newDictionary = InformationModel.MakeVariable(
+        browseName, 
+        OpcUa.DataTypes.String, 
+        FTOptix.Core.VariableTypes.LocalizationDictionary, 
+        new uint[2] { 
+            (uint)newDictionaryValues.GetLength(0), 
+            (uint)newDictionaryValues.GetLength(1) 
+        });
+    // Set the dictionary content
+    newDictionary.Value = new UAValue(newDictionaryValues);
+    // Check if the dictionary does not exist already, then add it
+    if (dictionaryOwner.Get(browseName) == null) 
+        dictionaryOwner.Add(newDictionary);
+}
+```
+
+## Add/Modify/Remove translation from a dictionary
+
+Dictionary values are stored in a bidimensional array of string, you need to handle this rectangular array and regenerate the UAValue to store into the dictionary.
+
+### Add elements to the dictionary
+
+This example provide a collection of array to add multiple records into the dictionary
+
+```csharp
+private void StuffAddDictionaryTranslations(IUAVariable dictionary, List<string[]> valuesToAdd)
+{
+    // A big dictionary may take a long processing time, so using a LongRunningTask is recommended to avoid blocking the main thread.
+    
+    // Validate input: if any of the inputs are null or empty, exit early.
+    if (dictionary == null || dictionary.Value.Value == null || valuesToAdd == null || valuesToAdd.Count <= 0)
+        return;
+
+    string[,] actualDictionaryValues;
+    try
+    {
+        // Attempt to cast the dictionary's value to a 2D string array (dictionary format).
+        actualDictionaryValues = dictionary.Value.Value as string[,];
+    }
+    catch
+    {
+        // If the dictionary value is not a valid 2D array, stop further processing.
+        return;
+    }
+
+    // List to store only verified values that can be safely added to the dictionary.
+    List<string[]> valuesVerifiedToAdd = new List<string[]>();
+
+    // Iterate through each value set to be added to the dictionary.
+    foreach (string[] valueToAdd in valuesToAdd)
+    {
+        if (valueToAdd == null)
+            continue; // Skip null entries.
+
+        // Check if the number of elements in the value matches the number of columns in the dictionary.
+        if (valueToAdd.Length != actualDictionaryValues.GetLength(1))
+        {
+            Log.Warning(LogicObject.BrowseName, "The count of elements to be added is different from the number of columns in the dictionary, skipped");
+            continue;
+        }
+
+        // Validate that the first column (key) is not null or empty.
+        if (string.IsNullOrEmpty(valueToAdd[0]))
+        {
+            Log.Warning(LogicObject.BrowseName, "Missing key, skipped");
+            continue;
+        }
+
+        // Check if the key already exists in the current dictionary.
+        string checkIfKeyExist = Enumerable
+            .Range(0, actualDictionaryValues.GetLength(0)) // Generate row indices.
+            .Where(x => actualDictionaryValues[x, 0] == valueToAdd[0]) // Check if the key matches the first column.
+            .Select(y => actualDictionaryValues[y, 0]) // Get the matching key.
+            .FirstOrDefault(); // Return the first match or null.
+
+        if (!string.IsNullOrEmpty(checkIfKeyExist))
+        {
+            Log.Warning(LogicObject.BrowseName, $"Key {valueToAdd[0]} already exists, cannot add to dictionary, use Edit method");
+            continue;
+        }
+
+        // Add the value to the list of verified values for addition.
+        valuesVerifiedToAdd.Add(valueToAdd);
+    }
+
+    // Create a new dictionary with additional rows for the new entries.
+    string[,] newDictionaryValues = new string[actualDictionaryValues.GetLength(0) + valuesVerifiedToAdd.Count, actualDictionaryValues.GetLength(1)];
+
+    // Copy the existing dictionary values to the new dictionary.
+    for (int i = 0; i < actualDictionaryValues.GetLength(0); i++)
+    {
+        for (int j = 0; j < actualDictionaryValues.GetLength(1); j++)
+        {
+            newDictionaryValues[i, j] = actualDictionaryValues[i, j];
+        }
+    }
+
+    // Add the verified new values to the new dictionary starting from the next available row.
+    int rowOffset = 0;
+    foreach (string[] valueToAdd in valuesVerifiedToAdd)
+    {
+        for (int i = 0; i < valueToAdd.Length; i++)
+        {
+            int rowIndex = actualDictionaryValues.GetLength(0) + rowOffset; // Calculate the row index for the new entry.
+            newDictionaryValues[rowIndex, i] = valueToAdd[i]; // Add the value to the corresponding position.
+        }
+        rowOffset++; // Move to the next row for subsequent entries.
+    }
+
+    // Update the dictionary's value with the new dictionary containing the added values.
+    dictionary.Value = new UAValue(newDictionaryValues);
+}
+
+```
+
+### Modify content of a dictionary
+
+This example provide a collection of array to edit multiple records into the dictionary. Into a single array you can only write the language value to modify (take in consideration to place in correct order) and leave other field empty.
+
+```csharp
+private void StuffModifyDictionaryTranslations(IUAVariable dictionary, List<string[]> valuesToEdit)
+{
+    // A big dictionary may take a long time to process, so using a LongRunningTask is recommended to avoid blocking processes.
+    
+    // Validate inputs: check if dictionary or its value is null, or if there are no values to edit.
+    if (dictionary == null || dictionary.Value.Value == null || valuesToEdit == null || valuesToEdit.Count <= 0)
+        return;
+
+    string[,] actualDictionaryValues;
+    try
+    {
+        // Attempt to cast the dictionary's value to a two-dimensional string array.
+        actualDictionaryValues = dictionary.Value.Value as string[,];
+    }
+    catch
+    {
+        // If the value cannot be cast, it may not be a dictionary, so stop further processing.
+        return;
+    }
+
+    // Iterate over each entry in the valuesToEdit list.
+    foreach (string[] valueToEdit in valuesToEdit)
+    {
+        // Skip null entries.
+        if (valueToEdit == null)
+            continue;
+
+        // Check if the entry length matches the number of dictionary columns.
+        if (valueToEdit.Length != actualDictionaryValues.GetLength(1))
+        {
+            Log.Warning(LogicObject.BrowseName, "The count of elements to be edited is different from the number of columns in the dictionary, skipped");
+            continue;
+        }
+
+        // Ensure the key (first element) is not null or empty.
+        if (string.IsNullOrEmpty(valueToEdit[0]))
+        {
+            Log.Warning(LogicObject.BrowseName, "Missing key, skipped");
+            continue;
+        }
+
+        // Find the row in the dictionary corresponding to the key.
+        int rowNumberToEdit = Enumerable
+            .Range(0, actualDictionaryValues.GetLength(0)) // Iterate over all rows.
+            .Where(x => actualDictionaryValues[x, 0] == valueToEdit[0]) // Check if the first column matches the key.
+            .FirstOrDefault(-1); // Default to -1 if no match is found.
+
+        // If the key does not exist in the dictionary, log a warning and skip the entry.
+        if (rowNumberToEdit == -1)
+        {
+            Log.Warning(LogicObject.BrowseName, $"Key {valueToEdit[0]} does not exist, cannot edit the dictionary, use Add method");
+            continue;
+        }
+
+        // Update the corresponding row with the new values.
+        for (int i = 0; i < valueToEdit.Length; i++)
+        {
+            // Only update non-empty values to avoid overwriting existing data with empty values.
+            if (!string.IsNullOrEmpty(valueToEdit[i]))
+                actualDictionaryValues[rowNumberToEdit, i] = valueToEdit[i];
+        }
+    }
+
+    // Update the dictionary with the modified values.
+    dictionary.Value = new UAValue(actualDictionaryValues);
+}
+
+```
+
+### Remove
+
+This example provide a list of keys to delete multiple records into the dictionary.
+
+```csharp
+private void StuffRemoveDictionaryTranslations(IUAVariable dictionary, List<string> keysToRemove)
+{
+    // A big dictionary may take a long processing time, usage of a LongRunningTask is recommended
+    if (dictionary == null || dictionary.Value.Value == null || keysToRemove == null || keysToRemove.Count <= 0)
+        return;
+    string[,] actualDictionaryValues;
+    try
+    {
+        actualDictionaryValues = dictionary.Value.Value as string[,];
+    }
+    catch
+    {
+        //Maybe is not a dictionary, so is better to stop processing here
+        return;
+    }
+    List<int> rowsToRemove = new List<int>();
+    const int defaultValue = 0;
+    foreach(string keyToRemove in keysToRemove) 
+    {
+        if (string.IsNullOrEmpty(keyToRemove))
+        {
+            Log.Warning(LogicObject.BrowseName, "Missing key, skipped");
+            continue;
+        }
+        int rowToDelete = Enumerable
+       .Range(0, actualDictionaryValues.GetLength(0))
+       .Where(x => actualDictionaryValues[x, 0] == keyToRemove)
+       .FirstOrDefault(defaultValue);
+        if (rowToDelete == defaultValue)
+        {
+            Log.Warning(LogicObject.BrowseName, $"Key {keyToRemove} not exist, cannot edit the dictionary, use Add method");
+            continue;
+        }
+        rowsToRemove.Add(rowToDelete);
+    }
+    if (rowsToRemove.Count >= actualDictionaryValues.GetLength(0))
+    {
+        Log.Error(LogicObject.BrowseName, "The rows to be removed are equal to or more than the dictionary entries with header, impossible to continue");
+        return;
+    }
+    string[,] newDictionaryValues = new string[actualDictionaryValues.GetLength(0) - rowsToRemove.Count, actualDictionaryValues.GetLength(1)];
+    int rowToWrite = 0;
+    for (int i = 0; i < actualDictionaryValues.GetLength(0); i++) 
+    {
+        if (!rowsToRemove.Contains(i))
+        {
+            for (int j = 0; j < actualDictionaryValues.GetLength(1); j++)
+            {
+                newDictionaryValues[rowToWrite, j] = actualDictionaryValues[i, j];
+            }
+            rowToWrite++;
+        }
+    }
+    dictionary.Value = new UAValue(newDictionaryValues);
+}
+```
+
+### Example of previous code snippets
+
+You can build a Design NetLogic with all previous methods to create and populate a Dictionary
+
+```csharp
+[ExportMethod]
+public void Method1()
+{
+    // Get to the translations folder
+    Folder translation = Project.Current.Get<Folder>("Translations");
+    // Create the new dictionary object
+    StuffMakeNewDictionary("MyNewDictionary", new string[6] { "", "it-IT", "en-US", "fr-FR", "es-ES","de-DE" }, translation);
+    // Set some content to the dictionary
+    List<string[]> fillThisDict = new List<string[]>
+    {
+        new string[6] { "keyHello1", "Ciao", "Hello", "Bonjour", "Hola", "Hallo" },
+        new string[6] { "keyHello", "Ciao", "Hello", "Bonjour", "Hola", "Hallo" },
+        new string[6] { "keyStart2", "Avviare!", "Start!", "Démarrer!", "Inicio!","Start!" },
+        new string[6] { "keyStop2", "Fermare", "Stop", "Arrêter", "Para", "Stopp" },
+        new string[6] { "keyStart", "Avviare", "Start", "Démarrer", "Inicio", "Start" },
+        new string[6] { "keyStop", "Fermare", "Stop", "Arrêter", "Para", "Stopp" },
+        new string[6] { "keyStop3", "Fermare", "Stop", "Arrêter", "Para", "Stopp" }
+    };
+    StuffAddDictionaryTranslations(translation.GetVariable("MyNewDictionary"), fillThisDict);
+    // Add even more lines to the dictionary
+    List<string[]> editThisDict = new List<string[]>
+    {
+        new string[6] { "keyHello", "Ciao!", "Hello!", "Bonjour!", "Hola!", "Hallo!" },
+        new string[6] { "keyStop", "Fermati!", "Stop", "Arrêter", "Para", "Stopp" },
+        new string[6] { "keyStart2", "Avviare", "Start", "Démarrer", "Inicio", "Start" }
+    };
+    StuffModifyDictionaryTranslations(translation.GetVariable("MyNewDictionary"), editThisDict);
+    // Remove some unused keys
+    List<string> removeToThisDict = new List<string>
+    {
+        "keyHello1",
+        "keyStart2",
+        "keyStop2",
+        "keyStop3"
+    };
+    StuffRemoveDictionaryTranslations(translation.GetVariable("MyNewDictionary"), removeToThisDict);
+}
+```
+
+## Send the current locale to the PLC
+
+> [!NOTE] 
+> This code might limit the flexibility of locales switching in FactoryTalk Optix. 
+
+By default, each session has its own independent locale. This means that the script will be triggered every time any connected session changes its locale. The last session to change the locale will update the value in the controller.
+
+This setup works fine if you are using only one session. However, if you are using multiple sessions, you should use a different approach. For example, you could log the locale change for each session separately into different variables.
+
+```csharp
+public class RuntimeNetLogic1 : BaseNetLogic
+{
+    // Place this code in the RuntimeNetLogic1.cs file
+    // in the MainWindow object of the project
+
+    public override void Start()
+    {
+        // Subscribe to the LocaleId variable change event
+        Session.ActualLocaleIdVariable.VariableChange += Session_LocaleIdVariable_VariableChange;
+        // You can also log the initial LocaleId value if needed
+        Log.Info("Initial LocaleId: " + Session.ActualLocaleId);
+    }
+
+    private void Session_LocaleIdVariable_VariableChange(object sender, VariableChangeEventArgs e)
+    {
+        // This code will be called when the LocaleId variable changes
+        // You can add your custom logic here
+        var newLocaleId = e.NewValue;
+        // For example, you can log the new LocaleId
+        Log.Info("New LocaleId: " + newLocaleId);
+        // Or send the new LocaleId to the PLC
+        Project.Current.Get<Variable>("CommDrivers/PLC1/Tags/LocaleId").Value = newLocaleId;
+    }
+
+    public override void Stop()
+    {
+        // Unsubscribe from the variable change event
+        if (Session.LocaleIdVariable != null)
+        {
+            Session.ActualLocaleIdVariable.VariableChange -= Session_LocaleIdVariable_VariableChange;
+        }
+    }
+}
+```