Page History

Upgrading to v10: Important Notice

The new Version 10 is a major update, introducing significant improvements and new technologies to enhance performance, security, and future platform support. Due to the extent of these changes, upgrading existing projects to V10 may require some manual adjustments to ensure compatibility.

Additionally, all projects should be revalidated in a lab environment before deployment in the field. This revalidation step is essential to confirm that each component functions optimally in the new version, and we cannot guarantee a smooth upgrade if you attempt to update without lab testing.

Upgrade Command

In order to upgrade a legacy project, you just need to put the <project>.tProj file in the folder mapped to the Solutions Manager, so that project will be visible on the Solutions List (press Refresh after changing files in the folders).

Only projects from versions 9.1 and 9.2 can be upgraded directly. For older project files, first use the 9.1 or 9.2 product to upgrade to that version, the then bring it to the final step on version 10.

When a file with the extension .tProj is found, it shows on the Solution List , with the prefix "Project." When a legacy project is selected,  the the "Upgrade Version" command button is enabled. 

When Upgrading:

• The previous

• project file remains intact

• ; the system uses a copy

• in the upgrade process.

• A new solution (with the .dbSln extension

• ) is created with the same name

• as the upgraded project (only the extensions of the file will be distinct).
• After the upgrade, only the new solution (.dbSln) will show on the

• Solution List (the legacy project file is kept hidden from the list).

The first time you open an imported solution, the Designer will prompt you to do a Build Command (Runtime→Build And Runtime → Build and Publish).

Manual Upgrade Corrections

Most of the replacement of new names and properties is executed automatically, but there are a few areas that a where manual interface intervention is necessary.

RuntimeUsers Database, TableName

The pre-defined value for the table name for RuntimeUsers is in version 9.2 or older was: EditSecurityUsers_Runtime. That name was replace This name has been replaced by SecurityRuntimeUsers. 

The Upgrade tools already tries attempt to find and correct that name in Scripts and Database connections automatically, but the DATABASE itself you will be connecting , we can't change to cannot be changed automatically. Therefore, before commission the commissioning version 10 to production, you need to rename the name is table in the target database , from EditSecurityUsers_Runtime to SecurityRuntimeUsers.

Advanced Toolkit applications

Some advanced applications using the product toolkits , and the API for programatic programmatic engineering (EngWrapper API) , are likely to lack compatibility due to the renaming of internal data structures and tables. Contact support if upgrading such applications. 

Themes

The Themes features from version 9.2 allowed extensive customization, with the drawback that but managing them could be quite complex to manage. 

The Themes features of in version was 10 have been expanded, with more built-in themes , and an extremely simplified interface. However, but the migration can't cannot be fully automated. Those solutions needs to have a review on Solutions need to be reviewed for the colors of screen screens and objects that were mapped to theme resources. 

Scripts Asynchronous Methods

Version 10 uses a more modern and efficient programming pattern that is Asynchronous called asynchronous methods. That allows better This improves performance on displays , and it is one of the technologies that enabled enables most of Windows WPF displays , to run also on WEB web HTML5 with no modifications. 

When creating new solutions, that this is done automatically for you. However, but legacy Displays that had displays with heavy CodeBehind Scripts, may need to the methods modified scripts may require modification of methods to use the async operator. 

For more information on Async programming: https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/

Calling Server Classes from Displays and Client Classes

 Now when calling Script Class Server method from Client scripts (Script Class Client or Display CodeBehind) should add "await" (C#) "Await" (VB.NET) for the HTML5 to work successfully.

C#:

public async Task DisplayOpening() { await @Script.Class.ServerMain.Method1(); }

VB.NET:

Public Async Function DisplayOpening() As Task Await @Script.Class.ServerMain.Method1() End Function

Correction of Logon() on CodeBehind

The method Logon() should be replaced by LogonAsync(), as well other synchronous methods shall be modified to there their async versions.   Here is the modification of the Logon() method, as it was very commonly used in the projects.

this.DialogOnOK = async function()
{
    var result = await @Client.LogOnAsync("user1", "pass1");
    return true;
};

public async Task<bool> DialogOnOK()
{
    var result = await @Client.LogOnAsync("user1", "pass1");
    return true;
}

Public Async Function DialogOnOK() As Task(Of Boolean)
    Dim result As Integer = Await @Client.LogOnAsync("user1", "pass1")
    Return True
End Function

Calling Async Methods

On the of reasons One reason the update of the code to use async methods is not fully automated , it's is that when on a method is modified to became become async, the other methods calling. that one, should be updated also, at its signature and return value is now a new onethat call it need to be updated as well. These calling methods must also be updated in their signatures and return values to accommodate the new async method. There are different ways to implement itthis, typically using await or Result operators; it wouldn't be passible to . It would not be feasible for the upgrade tool to automatically and safely modify all dependencies and application logic of the applicatoin to use the method asynchronously.

Here ia complete example, on how a Code Behind of a display was in earlier versions, with synchronous call, and the modified code using async calls.

Public Sub DisplayOpening()
	' Add your code here
	
End Sub

Public Sub DisplayIsOpen()
	' Add your code here
	
End Sub

Public Sub DisplayClosing()
	' Add your code here
	
End Sub

'This method is only called on Dialog displays
Public Function DialogOnOK() As Boolean
	Dim log As eSecurityErrors
	log = DirectCast(@Client.LogOn(@Client.InputUserName, @Client.InputPassword), eSecurityErrors)
	If log = eSecurityErrors.OK Then
		@Display.LogOn.Close()
		Return True
	End If
	Dim msg As String = @Client.Locale("Could not logon") + " (" + @Client.Locale(log.ToString()) + ")"
	MessageBox.Show(msg)
	Return False
End Function

Public Sub ExecuteLogOff(ByVal sender As Object, ByVal e As MouseButtonEventArgs)
	@Client.LogOnGuest()
	@Display.LogOn.Close()
End Sub

Public Sub MouseLeftButtonOk(ByVal sender As Object, ByVal e As System.Windows.Input.InputEventArgs)
	 DialogOnOK()
End Sub

The previous code

in version 10

will issue

warnings, not errors, as it can still

be used in

displays that are WPF (Windows) only.

The

warnings are issued because the code is no longer acceptable for pages targeting Web

HTML5. Therefore

, it cannot be used in portable pages (Web and Windows ready), which are the preferred option moving forward.

It's

It’s important to emphasize that using async

also benefits

WPF-Windows

applications by making UI interactions

more responsive.

The upgrade tool will only attempt to automatically update the LogOn page if it was kept as provided in the templates. The following code shows the changes needed to manually correct the LogOnPage if necessary, and the patterns of using async and await can be applied to other pages that require changes.

Public Subpublic void DisplayIsOpen()
End {Sub
}

publicPublic voidSub DisplayClosing()
End {
}Sub

publicPublic asyncAsync Task<bool>Function DialogOnOK() {As Task(Of Boolean)
	eSecurityErrorsDim log; As eSecurityErrors
	log = DirectCast(eSecurityErrors) awaitAwait @Client.LogOnAsync(@Client.InputUserName, @Client.InputPassword);, eSecurityErrors)
	ifIf (log == eSecurityErrors.OK) {Then
		@Display.LogOn.Close();
		returnReturn true;True
	}End If
	stringDim msg As String = @Client.Locale("Could not logon") + " (" + @Client.Locale(log.ToString()) + ")";
	MessageBox.Show(msg);
	returnReturn false;
}False
End Function

publicPublic asyncAsync TaskFunction ExecuteLogOff(objectByVal sender As Object, MouseButtonEventArgsByVal e As MouseButtonEventArgs) {As Task
	awaitAwait @Client.LogOnGuestAsync();
	@Display.LogOn.Close();
}End Function

publicPublic asyncAsync TaskFunction MouseLeftButtonOk(objectByVal sender As Object, ByVal e As System.Windows.Input.InputEventArgs e) {
	// Add your code hereAs Task
	awaitAwait DialogOnOK();
}End 


Function

public voidPublic Sub DisplayIsOpen() {
End Sub}

Publicpublic Subvoid DisplayClosing() {
End Sub}

Publicpublic Asyncasync FunctionTask<bool> DialogOnOK() As Task(Of Boolean){
	DimeSecurityErrors log As eSecurityErrors;
	log = DirectCast(AwaiteSecurityErrors) await @Client.LogOnAsync(@Client.InputUserName, @Client.InputPassword), eSecurityErrors);
	Ifif (log == eSecurityErrors.OK) Then{
		@Display.LogOn.Close();
	Return	return Truetrue;
	End If}
	Dimstring msg As String = @Client.Locale("Could not logon") + " (" + @Client.Locale(log.ToString()) + ")";
	MessageBox.Show(msg);
	Returnreturn False
End Functionfalse;
}

Publicpublic Asyncasync FunctionTask ExecuteLogOff(ByValobject sender As Object, ByValMouseButtonEventArgs e As MouseButtonEventArgs) As Task{
	Awaitawait @Client.LogOnGuestAsync();
	@Display.LogOn.Close();
End Function}

Publicpublic Asyncasync FunctionTask MouseLeftButtonOk(ByValobject sender As Object, ByVal e As System.Windows.Input.InputEventArgs e) As Task
	Await {
	// Add your code here
	await DialogOnOK();
End} Function

Deprecated Features

List of Deprecated features:

• Synchronous calls on SQL Queries and various other methods. The system will still compile, but a warning will be issued.
• Custom Theme

• Editing for specific controls

• is no longer support. We also no longer allow different solutions to have distinct IDs for the theme resources,

• as those are now standard. 

• The syntax <TagProvider>.("Topic Path") is no longer supported. You now need to map the TagProvider to the AssetTree.

• Generation and visualization for XPS documents is no longer

• supported.

In this section: