@aryacode/dsh-engineering 0.5.0 → 0.6.0

package/vendor/optix/netlogic/pages/serial-port.md

@@ -0,0 +1,357 @@
+# Serial port
+
+Communication using the serial port is only allowed using the SerialPort driver provided by FactoryTalk Optix.
+
+On Windows, the name of the COM port must be specified as `COMx`, where `x` is the port number (e.g., `COM1`, `COM2`, etc.). On embedded devices, the name of the serial port is automatically mapped to the serial port index of the device (e.g., `COM0` is mapped to the serial port at index 0 - the embedded serial port of OptixPanels - which is internally mapped to `/dev/serial0`).
+
+> [!TIP]
+> For the OptixPanel standard, the embedded serial port is available as `COM1` (internally mapped to `/dev/serial1`).
+
+So, if the project configures `COM0` as serial port name, on Windows it will try to open `COM0`, while on embedded devices it will try to open `/dev/serial0` with no need to change anything on the project.
+
+> [!NOTE]
+> All the serial port write operations (like the `Write` and `WriteBytes` methods) are **non-blocking**, meaning that the NetLogic code will continue immediately even if the data is not yet written to the serial port.
+
+> [!NOTE]
+> Serial port communication can only be performed at runtime. Attempting to read from or write to the serial port at design time will not work.
+
+## Polling mode
+
+```csharp
+public class RuntimeNetlogic1 : BaseNetLogic
+{
+    private SerialPort serialPort;
+    private PeriodicTask periodicTask;
+    
+    public override void Start()
+    {
+        serialPort = (SerialPort)Owner;
+        periodicTask = new PeriodicTask(Read, 300, Owner);
+        periodicTask.Start();
+    }
+
+    private void Read()
+    {
+        try
+        {
+            ReadImpl();
+        }
+        catch (Exception ex)
+        {
+            Log.Error("Failed to read from Modbus: " + ex);
+        }
+    }
+
+    private void ReadImpl()
+    {
+        serialPort.WriteBytes(Serialize());
+        var result = serialPort.ReadBytes(3);
+        if ((result[1] & 0x80) == 0)
+        {
+            result = serialPort.ReadBytes((uint)(result[2] + 2));
+            Log.Info(Deserialize(result));
+        }
+        else
+        {
+            Log.Error("Failed to read from Modbus");
+        }
+    }
+
+    private byte[] Serialize()
+    {
+        var buffer = new byte[]
+        {
+            0x01, // UnitId
+            0x03, // Function code
+            0x00, // Starting address
+            0x00,
+            0x00, // Quantity Of Registers
+            0x01,
+            0x84, // CRC
+            0x0a
+        };
+        return buffer;
+    }
+
+    private ushort Deserialize(byte[] buffer)
+    {
+        var first = (ushort)buffer[1];
+        var second = (ushort)(buffer[0] << 8);
+        return (ushort)(first | second);
+    }
+}
+```
+
+## Event mode
+
+```csharp
+public class RuntimeNetlogic1 : BaseNetLogic
+{
+    private SerialPort serialPort;
+    private LongRunningTask task;
+
+    public override void Start()
+    {
+        serialPort = (SerialPort)Owner;
+        serialPort.Timeout = TimeSpan.FromMilliseconds(0.0);
+        task = new LongRunningTask(Run, Owner);
+        task.Start();
+    }
+
+    [ExportMethod]
+    public void OnClick()
+    {
+        // Cancel current read
+        serialPort.CancelRead();
+        task.Cancel();
+        // Start new read
+        task = new LongRunningTask(Run, Owner);
+        task.Start();
+    }
+
+    private void Run()
+    {
+        while(!task.IsCancellationRequested)
+        {
+            try
+            {
+                // Block until 3 bytes arrive on serial
+                var result = serialPort.ReadBytes(3);
+                foreach (var b in result)
+                    Log.Info(String.Format("0x{0:x2}", b));
+            }
+            catch (ReadCanceledException ex)
+            {
+                // In case of read canceled, exit from the loop
+                Log.Info(ex.Message);
+                return;
+            }
+            catch (Exception e)
+            {
+                Log.Error(e.Message);
+            }
+        }
+    }
+
+    public override void Stop()
+    {
+        // Explicit call to Close to cancel pending read (if any)
+        serialPort.Close();
+        task.Cancel();
+    }
+}
+```
+
+## Custom protocol implementation example
+
+```csharp
+#region Using directives
+using System;
+using UAManagedCore;
+using OpcUa = UAManagedCore.OpcUa;
+using FTOptix.UI;
+using FTOptix.NativeUI;
+using FTOptix.HMIProject;
+using FTOptix.Retentivity;
+using FTOptix.CoreBase;
+using FTOptix.Core;
+using FTOptix.NetLogic;
+using FTOptix.SerialPort;
+using FTOptix.CommunicationDriver;
+using System.Collections.Generic;
+#endregion
+
+public class SerialPortLogic : BaseNetLogic
+{
+    public override void Start()
+    {
+        // Get the input and output variables
+        IncomingString = LogicObject.GetVariable("IncomingString");
+        OutgoingString = LogicObject.GetVariable("OutgoingString");
+        // Prepare the event to be triggered when the OutgoingString variable changes
+        OutgoingString.VariableChange += OutgoingString_VariableChange;
+        // Starts the COM port reading task as soon as the user-defined logic is started
+        comPort = (SerialPort)Owner; // Cast the Owner property to the SerialPort type
+        comPort.Timeout = TimeSpan.FromMilliseconds(100); // Adjust as needed
+        serialPortTask = new LongRunningTask(ReadSerialPort, LogicObject); // Create a new task to read the COM port
+        serialPortTask.Start(); // Start the task
+    }
+
+    private void OutgoingString_VariableChange(object sender, VariableChangeEventArgs e)
+    {
+        dataToSend = e.NewValue.Value.ToString();
+    }
+
+    public override void Stop()
+    {
+        OutgoingString.VariableChange -= OutgoingString_VariableChange;
+        serialPortTask?.Dispose();
+    }
+
+    private void ReadSerialPort()
+    {
+        Log.Info("ReadSerialPort", "Starting to read the COM port");
+        byte incomingChar;
+        List<byte> buffer = [];
+
+        // This loop keeps reading the COM port in case of an exception
+        while (!serialPortTask.IsCancellationRequested)
+        {
+            Log.Info("ReadSerialPort", "Entering main loop");
+
+            try
+            {
+                Log.Info("ReadSerialPort", "Opening the COM port");
+                // Open the COM port
+                comPort.Open();
+                incomingChar = 0x00;
+                Log.Info("ReadSerialPort", "COM port opened");
+
+                // This loop reads the COM port until the termination character is received
+                while (!serialPortTask.IsCancellationRequested)
+                {
+                    try
+                    {
+                        // Read the incoming character
+                        incomingChar = comPort.ReadByte();
+
+                        // If the incoming character is not the termination character, add it to the buffer
+                        if (incomingChar != terminationChar)
+                        {
+                            buffer.Add(incomingChar);
+                        }
+                        else
+                        {
+                            // If the incoming character is the termination character,
+                            // convert the buffer to a string and set the IncomingString variable
+                            string message = System.Text.Encoding.ASCII.GetString(buffer.ToArray());
+                            IncomingString.Value = message;
+                            Log.Info("ReadSerialPort", $"Received message: {message}");
+                            buffer.Clear();
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        if (!ex.Message.Contains("read timeout"))
+                        {
+                            // If another exception occurs, log the error and break the loop
+                            Log.Error("ReadSerialPort", ex.Message);
+                            throw;
+                        }
+                    }
+
+                    // Check if data needs to be sent
+                    if (dataToSend != null)
+                    {
+                        // Send the data and the termination character
+                        Log.Info("ReadSerialPort", "Sending data: " + dataToSend);
+                        comPort.WriteBytes(System.Text.Encoding.ASCII.GetBytes(dataToSend));
+                        comPort.WriteBytes(new byte[] { terminationChar });
+                        dataToSend = null;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                // Insert code to handle exceptions
+                Log.Error("ReadSerialPort", ex.Message);
+                comPort.Close();
+            }
+            finally
+            {
+                Log.Info("ReadSerialPort", "Closing the COM port");
+                comPort.Close();
+            }
+        }
+
+        Log.Info("ReadSerialPort", "Exiting main loop");
+    }
+
+    private const byte terminationChar = 0x0A;
+    private IUAVariable IncomingString;
+    private IUAVariable OutgoingString;
+    private SerialPort comPort;
+    private LongRunningTask serialPortTask;
+    private string dataToSend;
+}
+```
+
+## Using the serial port to control an external device
+
+This example shows how to keep the TX line HIGH on a serial port to power an external device that requires it (like to power an external relay module).
+
+> [!WARNING]
+> The TX line of a serial port is not designed to provide power to external devices. Ensure that the external device's power requirements do not exceed the capabilities of the serial port to avoid damage. An intermediate driver circuit (current or voltage buffer) is strictly required.
+
+> [!NOTE]
+> Depending on the hardware interface, the TX line might be inverted. Please check the hardware documentation for more details.
+
+```csharp
+using System;
+using System.Linq;
+using FTOptix.CommunicationDriver;
+using FTOptix.NetLogic;
+using FTOptix.SerialPort;
+using UAManagedCore;
+
+public class MinimalSerialPortLogic : BaseNetLogic
+{
+    public override void Start()
+    {
+        // Setup Serial Port
+        serialPort = (SerialPort)Owner;
+        serialPort.Baudrate = 9600;
+        serialPort.FlowControl = FlowControl.None;
+        serialPort.DataSize = 8;
+        serialPort.Parity = Parity.None;
+        serialPort.StopBits = StopBits.One;
+        serialPort.Timeout = TimeSpan.FromMilliseconds(100);
+
+        // Calculate buffer size for 2 seconds transmission
+        // Baudrate: 9600 bits/sec
+        // Bits per byte: 10 (1 start + 8 data + 1 stop)
+        // Bytes per second: 9600 / 10 = 960 bytes/sec
+        // For 2000ms: 960 * 2 = 1920 bytes
+        var bytesPerSecond = serialPort.Baudrate / (serialPort.DataSize + 2);
+        var bufferSize = (bytesPerSecond * TX_DURATION_MS) / 1000;
+        txBuffer = Enumerable.Repeat((byte)0x00, (int)bufferSize).ToArray();
+
+        Log.Info("MinimalSerialPortLogic", $"Initialized with buffer size: {txBuffer.Length} bytes for {TX_DURATION_MS}ms transmission");
+    }
+
+    public override void Stop()
+    {
+        if (serialPort != null)
+        {
+            serialPort.Close();
+            serialPort = null;
+        }
+    }
+
+    /// <summary>
+    /// Activates the TX pin for the configured duration by writing the pre-calculated buffer.
+    /// WriteBytes is asynchronous - it queues the data and returns immediately.
+    /// The actual transmission will take approximately TX_DURATION_MS.
+    /// </summary>
+    [ExportMethod]
+    public void SetOutput()
+    {
+        try
+        {
+            var stopwatch = System.Diagnostics.Stopwatch.StartNew();
+            serialPort.WriteBytes(txBuffer);
+            stopwatch.Stop();
+
+            Log.Info("SetOutput", $"TX activated. Buffer: {txBuffer.Length} bytes, Queue time: {stopwatch.ElapsedMilliseconds}ms, Expected TX duration: {TX_DURATION_MS}ms");
+        }
+        catch (Exception ex)
+        {
+            Log.Error("SetOutput", $"Failed to write to serial port: {ex.Message}");
+        }
+    }
+
+    private SerialPort serialPort;
+    private byte[] txBuffer;
+    private const int TX_DURATION_MS = 2000;
+}
+```

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

@@ -0,0 +1,58 @@
+# Sessions
+
+> [!NOTE]
+> Session operations can only be performed at runtime. Attempting to manipulate sessions at design time will not work.
+
+## Getting the number of the WebPresentationEngine sessions
+
+```csharp
+ /// <summary>
+ /// Retrieves the number of active Web sessions
+ /// </summary>
+ /// <param name="webPresentationEngineNodeId">NodeId of the WebPresentationEngine node</param>
+ /// <param name="activeWebSessionNumber">Counting active web sessions</param>
+ [ExportMethod]
+ public void GetActiveWebSessionsNumber(NodeId webPresentationEngineNodeId, out int activeWebSessionNumber)
+ {
+     try
+     {
+         // Get the current WebPresentationEngine from the project
+         PresentationEngine webPresentationEngine = InformationModel.Get<PresentationEngine>(webPresentationEngineNodeId);
+         // Call the method to read the active sessions
+         activeWebSessionNumber = GetWebPresentationEngineSessions(webPresentationEngine).Count();
+     }
+     catch (Exception ex)
+     {
+         Log.Error(ex.Message);
+         activeWebSessionNumber = -1;
+     }
+ }
+
+ // Use reflections to get the sessions (check where user is present (like Anonymous))
+ private static IEnumerable<UISession> GetWebPresentationEngineSessions(PresentationEngine webPresentationEngine) => webPresentationEngine.Sessions.Where(s => s.User != null);
+```
+
+## Impersonate a session
+
+Every operation being done on the Optix core must be done in the context of a session. When you are invoking code from an asynchronous method, you must always bind to an existing session, even if for a short time.
+
+> [!TIP]
+> This is a very edge case, if you need to perform asynchronous operation without having to deal with sessions, it is a better choice to use [async tasks](./async-tasks.md) instead.
+
+If no session is impersonated, the code will likely cause the runtime to crash (even with simple operation like toggling a variable).
+
+```csharp
+public void DoSomethingAsynchronously()
+{
+    // Get the first available session
+    var sessionHandler = LogicObject.Context.Sessions.ImpersonateRootTemporary();
+    if (sessionHandler != null)
+    {
+        // Do something in the context of the session
+        var someVariable = InformationModel.GetVariable("SomeVariable");
+        someVariable.Value = true;        
+    }
+    // Always dispose the session handler to release the session
+    sessionHandler?.Dispose();
+}
+```

package/vendor/optix/netlogic/pages/system-node.md

@@ -0,0 +1,153 @@
+# The system object
+
+The "System" object is a special node which provides some methods and events to interact with Optix devices (like OptixPanel, OptixEdge, etc)
+
+> [!NOTE]
+> The System node can only be manipulated at runtime. Attempting to call its methods or subscribe to its events at design time will not work.
+
+## Load a new application
+
+Please note:
+- Application must be exported by FactoryTalk Optix Studio with the same version that was previously used to deploy the original application
+- Exported application must be protected by a password
+- The import procedure might take some time, please wait for the confirmation message
+
+```csharp
+#region Using directives
+using System;
+using UAManagedCore;
+using OpcUa = UAManagedCore.OpcUa;
+using FTOptix.UI;
+using FTOptix.NativeUI;
+using FTOptix.HMIProject;
+using FTOptix.Retentivity;
+using FTOptix.CoreBase;
+using FTOptix.Core;
+using FTOptix.NetLogic;
+using FTOptix.System;
+using System.IO;
+using System.Runtime.Versioning;
+#endregion
+
+public class RuntimeNetLogic1 : BaseNetLogic
+{
+    public override void Start()
+    {
+        // Nothing to do
+    }
+
+    public override void Stop()
+    {
+        systemNode.OnLoadApplicationStatusEvent -= SystemNode_OnLoadApplicationStatusEvent;
+    }
+
+    [ExportMethod]
+    public void LoadNewApplication(string password, bool deleteApplicationFiles)
+    {
+        // Get to the system node
+        systemNode = Project.Current.Get<FTOptix.System.System>("System/System");
+        // Get the new application path
+        var newApplicationPath = ResourceUri.FromProjectRelativePath("NewApplication.z");
+
+        // Subscribe to the application load event
+        systemNode.OnLoadApplicationStatusEvent += SystemNode_OnLoadApplicationStatusEvent;
+
+        // Load the new application
+        if (systemNode.LoadApplication(newApplicationPath.Uri, password, deleteApplicationFiles))
+        {
+            // Call to the SystemManager API to load the new application was successful
+            Log.Info("LoadApplication", "Load application call was successful, please wait for the process to complete");
+        }
+        else
+        {
+            // Call to the SystemManager API to load the new application failed
+            Log.Error("LoadApplication", "Failed to load application, call to the SystemManager APIs failed");
+        }
+    }
+
+    private void SystemNode_OnLoadApplicationStatusEvent(object sender, LoadApplicationStatusEvent e)
+    {
+        if (e.Status == LoadApplicationStatus.Success)
+        {
+            // Application loaded successfully
+            Log.Info("LoadApplicationStatus", "Application loaded successfully");
+        }
+        else
+        {
+            // Application failed to load
+            Log.Error("LoadApplicationStatus", "Failed to load application: " + e.Status);
+        }
+    }
+
+    FTOptix.System.System systemNode;
+}
+```
+
+## Example: system and session variables (user, time, USB, IP)
+
+```csharp
+/// <summary>
+/// Periodically populate NetLogic variables with system and session information
+/// (active user, locale, current time components, random values and network/IP).
+/// Intended for Runtime NetLogic.
+/// </summary>
+private Random rnd = new Random();
+
+private void OneSecondSystemVariables()
+{
+    // User and session info
+    LogicObject.GetVariable("ActiveUser").Value = Session.User.BrowseName;
+    LogicObject.GetVariable("ActiveUserLocaleId").Value = Session.User.LocaleIds[0];
+    try { LogicObject.GetVariable("ActiveUserLanguage").Value = Session.User.Languages[0]; }
+    catch { LogicObject.GetVariable("ActiveUserLanguage").Value = "Language not selected"; }
+
+    // Time information
+    LogicObject.GetVariable("ActTimeSec").Value = DateTime.Now.Second;
+    LogicObject.GetVariable("ActTimeMin").Value = DateTime.Now.Minute;
+    LogicObject.GetVariable("ActTimeHour").Value = DateTime.Now.Hour;
+    LogicObject.GetVariable("ActTimeDay").Value = DateTime.Now.Day;
+    LogicObject.GetVariable("ActTimeMonth").Value = DateTime.Now.Month;
+    LogicObject.GetVariable("ActTimeYear").Value = DateTime.Now.Year;
+    LogicObject.GetVariable("ActTimeDayOfWeek").Value = (int)DateTime.Now.DayOfWeek;
+    LogicObject.GetVariable("ActTimeString").Value = DateTime.Now.ToShortTimeString();
+    LogicObject.GetVariable("ActDateString").Value = DateTime.Now.ToShortDateString();
+
+    // Random numbers
+    LogicObject.GetVariable("SimRandInt").Value = rnd.Next(32768);
+    LogicObject.GetVariable("SimSinDouble").Value = Math.Sin(Math.PI * rnd.Next(361) / 180.0);
+    LogicObject.GetVariable("SimCosDouble").Value = Math.Cos(Math.PI * rnd.Next(361) / 180.0);
+
+    // Active alarms count (safe navigation)
+    IContext context = LogicObject.Context;
+    var retainedAlarms = context.GetNode(QPlatform.Alarm.Objects.RetainedAlarms);
+    var localizedAlarmsVariable = retainedAlarms?.Children.Get<IUAVariable>("LocalizedAlarms");
+    var localizedAlarmsNodeId = localizedAlarmsVariable != null ? (NodeId)localizedAlarmsVariable.Value : NodeId.Empty;
+    IUANode localizedAlarmsContainer = null;
+    if (localizedAlarmsNodeId != null && !localizedAlarmsNodeId.IsEmpty)
+        localizedAlarmsContainer = context.GetNode(localizedAlarmsNodeId);
+    LogicObject.Children.Get<IUAVariable>("NumActiveAlarms").Value = localizedAlarmsContainer?.Children.Count ?? 0;
+    LogicObject.Children.Get<IUAVariable>("LastAlarmText").Value = localizedAlarmsContainer?.Children.LastOrDefault()?.BrowseName ?? "";
+
+    // USB present detection using ResourceUri catch
+    var pathUsbResourceUri = new ResourceUri("%USB1%");
+    try { var uri = pathUsbResourceUri.Uri; LogicObject.GetVariable("UsbPresent").Value = true; }
+    catch { LogicObject.GetVariable("UsbPresent").Value = false; }
+
+    // Network parameters (Windows only)
+    if (LogicObject.GetVariable("Windows").Value)
+    {
+        try
+        {
+            string hostName = Dns.GetHostName();
+            var host = Dns.GetHostEntry(hostName);
+            var ipv4s = host.AddressList.Where(a => a.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork).ToArray();
+            if (ipv4s.Length > 0) LogicObject.GetVariable("IP1").Value = ipv4s[0].ToString();
+            if (ipv4s.Length > 1) LogicObject.GetVariable("IP2").Value = ipv4s[1].ToString();
+        }
+        catch (Exception ex)
+        {
+            Log.Warning("OneSecondSystemVariables", "Unable to read IP addresses: " + ex.Message);
+        }
+    }
+}
+```

package/vendor/optix/netlogic/pages/template-library.md

@@ -0,0 +1,127 @@
+# Template Library
+
+## Import an object from the template library
+
+This feature allows you to import objects from the template library into your project. The imported object will be placed in the specified folder. The object can be an instance or a type.
+
+> [!TIP]
+> This feature got introduced in FactoryTalk Optix 1.6.X
+
+> [!NOTE]
+> Template library operations can only be performed at design time. Attempting to manipulate the template library at runtime will not work.
+
+### Import item syntax
+
+```csharp
+public static class TemplateLibrary
+{
+    public static IUANode ImportLibraryItem(IUANode destinationNode, NodeClass nodeClass, string libraryName,
+        string itemPath, List<TypeConflictResolutionChoice> conflictResolutionChoices = null,
+        bool preserveTypeDependencyPaths = false);
+}
+```
+
+### Import the LoginForm from the Widgets library example
+
+```csharp
+[ExportMethod]
+public void ImportLoginFormFromLibrary()
+{
+    // The place where the object will be imported
+    var targetFolder = Project.Current.Get("UI");
+    // Import the object
+    // Syntax: ImportLibraryItem(<item destination>, <node class (type or instance)>, <name of the library>, <name of the library item>)
+    var myWidget = TemplateLibrary.ImportLibraryItem(targetFolder, NodeClass.ObjectType, "Widgets", "LoginForm");
+    // Log the result
+    Log.Info($"Imported LoginForm from library to: {Log.Node(myWidget)}");
+}
+```
+
+## Specifying a conflict resolution
+
+If the imported element already exists in the target folder, you can specify a conflict resolution strategy.
+
+### Conflict resolution syntax
+
+A list of `TypeConflictResolutionChoice` structures is used to specify the conflict resolution strategy. The structure contains the following fields:
+
+```csharp
+public struct TypeConflictResolutionChoice
+{
+    public TypeConflictResolutionChoice(string browseName, NodeClass nodeClass, ConflictResolution resolution)
+    {
+        BrowseName = browseName;
+        NodeClass = nodeClass;
+        Resolution = resolution;
+    }
+
+    public readonly string BrowseName;
+    public readonly NodeClass NodeClass;
+    public readonly ConflictResolution Resolution;
+}
+```
+
+### Conflict resolution example
+
+ The following example will import the LoginForm from the TeamplateLibrary by overwriting the existing element (if any):
+
+```csharp
+using UAManagedCore;
+using FTOptix.HMIProject;
+using FTOptix.NetLogic;
+using System.Collections.Generic;
+using static UAManagedCore.TemplateLibrary;
+
+public class DesignTimeNetLogic1 : BaseNetLogic
+{
+    [ExportMethod]
+    public void ImportLoginFormFromLibrary()
+    {
+        // Conflict resolution strategy
+        var conflictResolutionChoices = new List<TypeConflictResolutionChoice>
+        {
+            // This is the list of elements which are inside the LoginForm object, we can specify how to handle each of them
+            new TypeConflictResolutionChoice("LoginForm", NodeClass.ObjectType, ConflictResolution.Replace),
+            new TypeConflictResolutionChoice("Login", NodeClass.ObjectType, ConflictResolution.Replace),
+            new TypeConflictResolutionChoice("LoginPasswordExpiredDialog", NodeClass.ObjectType, ConflictResolution.Replace),
+            new TypeConflictResolutionChoice("LoginChangePasswordForm", NodeClass.ObjectType, ConflictResolution.Replace),
+            new TypeConflictResolutionChoice("Logout", NodeClass.ObjectType, ConflictResolution.Replace),
+            new TypeConflictResolutionChoice("OAuth2Login", NodeClass.ObjectType, ConflictResolution.Replace)
+        };
+        // The place where the object will be imported
+        var targetFolder = Project.Current.Get("UI");
+        // Import the object
+        // Syntax: ImportLibraryItem(<item destination>, <node class (type or instance)>, <name of the library>, <name of the library item>)
+        var myWidget = TemplateLibrary.ImportLibraryItem(targetFolder, NodeClass.ObjectType, "Widgets", "LoginForm", conflictResolutionChoices);
+        // Log the result
+        Log.Info($"Imported LoginForm from library to: {Log.Node(myWidget)}");
+    }
+}
+```
+
+## Getting better performance
+
+If you are importing a large object with many dependencies, you can improve the performance by calling the import routine using a LongRunningTask.
+
+### Importing a large object using a LongRunningTask
+
+```csharp
+[ExportMethod]
+public void ImportLargeObjectFromLibrary()
+{
+    // Import the object
+    var importWidgetTask = new LongRunningTask(ImportLoginForm, LogicObject);
+    importWidgetTask.Start();
+}
+
+private void ImportLoginForm()
+{
+    // The place where the object will be imported
+    var targetFolder = Project.Current.Get("UI");
+    // Import the object
+    // Syntax: ImportLibraryItem(<item destination>, <node class (type or instance)>, <name of the library>, <name of the library item>)
+    var myWidget = TemplateLibrary.ImportLibraryItem(targetFolder, NodeClass.ObjectType, "Widgets", "LoginForm");
+    // Log the result
+    Log.Info($"Imported LoginForm from library to: {Log.Node(myWidget)}");
+}
+```