What’s New in QuickOPC 5.35

Previous: What’s New in QuickOPC 5.34

Key changes:

• Live Binding Improvements
• Streamlined Packaging and Installation
• Support for Windows 10
• Support for Visual Studio 2015

Targeting

• Added official support for Windows 10.
• Added official support for Visual Studio 2015.

Installation

• The default installation option is now “Express install for .NET development only”.
• Removed the embedded installations (prerequisites) under “Included software we depend on”, as no longer needed: Microsoft Visual C++ Redistributables, OPC Core Components, OPC UA Local Discovery Server. For details, see “Packaging” below.
• Added more assemblies (ending with “Toolbox” in their name) under the “Design” folder (not of concern to the application developer).
• Builds 515.1 and higher: The code signing certificate used is now “COMODO RSA Code Signing CA” and uses RSA256.

Packaging

• QuickOPC for OPC Classic no longer requires Microsoft Visual C++ Redistributables be installed. The necessary files are “boxed” with the QuickOPC assemblies, using a special technique.
• QuickOPC for OPC Classic no longer requires OPC Core Components be installed (on the client side). The necessary files and COM library registry entries are “boxed” with the QuickOPC assemblies, using a special technique.
• QuickOPC for OPC Unified Architecture no longer requires OPC UA Local Discovery Server be installed (on the client side). The necessary file (UA Certificate Generator) is “boxed” with the QuickOPC assemblies, using a special technique.
• In order to improve application startup speed, conserve memory, or in edge cases where the “boxing” approach fails, a user can still install any of the above prerequisites, and QuickOPC will use the software installed on the disk.
• Added several assemblies; these also need to be deployed with the user’s project. They are: BoxedAppSDK.Managed, OpcLabs.BoxOpcUACertificateGenerator, OpcLabs.BoxOpcCorePS, OpcLabs.BoxVC120Redist.

Platforms

• Removed Windows 8 (as such) from list of officially supported operating systems (although it probably works fine). The supported flavor is Windows 8.1 with Update.

User Interface

• All OPC browsing dialogs now have an additional SizeFactor property. The property allows the developer to influence the (initial) size of the dialog on screen. It can be set to one of the pre-defined values (SizeFactors.Small/Normal/Large/ExtraLarge), or to any SizeF structure, defining a width and height relative to the normal size. An additional SizeFactorName is provided primarily to allow easy access to this feature to COM callers.
• All OPC browsing dialogs now have an additional RetainAppearance property. When set (which is now the default behavior), the dialog retains its appearance (mainly, the location and size), between invocations. It is also possible to call the new RevertAppearance() method on the dialog, to restore the original values.
• OPC Unified Architecture browsing now offers a “well-known” node host “opcua.demo-this.com” under the Hosts, in order to visibly offer a ready-to-use server to the user and facilitate easy experimentation.

Live Binding

• When repeatedly using any of the “Bind to…” commands, the browsing now continues at the recently selected node. This allows for easier binding of multiple components to a set of related nodes. This approach is only used when a corresponding template element in DABinder or UABinder is not filled in.
• When repeatedly using any of the “Bind to…” commands, the browsing dialog now retains its location and size between invocations, making it easy for the user to position it conveniently during the design session.
• When binding .NET members, you can now specify not just a member name, but a whole path to it – i.e. it is now possible to bind sub-members as well. The path is a sequence of member names, separated by dots. For example, for binding on a ListBox component, it is possible to set the target path to “Items.Add”, which means that we bind the Add method of the Items collection of the ListBox (in effect, this will append incoming values as new values to the ListBox). Similarly, when selecting event sources, you can select events that reside on properties or sub-properties of components. If you want to specify the path (sub-members) and not just a single member, you use the new properties ValueTarget.TargetPath or EventSource.SourcePath.
• Added a UI editor for element paths described above. By pressing a down-arrow symbol next to the path, the user is offered a tree of available members and sub-members, with various filtering and sorting capabilities.

• When binding .NET members (methods) that have multiple overloads, it is now possible to specify the desired method signature using a type name in parenthesis, added to the element path. For example, if you wanted to bind the Add method of the Items collection of a ListView, there are two overloads that take one input argument, and the Live Binding would not know which one to use. By using a target path “Items.Add(System.String)”, you will instruct the Live Binding to use the overload that accepts string as an input.
• The various new formatting types for objects such as OperationResult, DAVtq, DAVtqResult, UAAttributeData, UAAttributeDataResult, etc. (described here under Components Core Improvements), are available for use in Live Binding. This makes it easy to format compound values for display purposes, without having to write any code.
• The “Binding Collection Editor” form now has a horizontal splitter, making it easier to customize it to different needs.

Live Binding – Connectivities and Point Binder

• QuickOPC now has a more unified approach to live binding. The approach merges commonalities between OPC “Classic” and OPC Unified Architecture bindings into a single PointBinder component. The PointBinder is agnostic of the actual data source; it accepts a “connectivity” object which serves as a data source. As opposed to the old DABinder or UABinder, the PointBinder is not based on the subset of live mapping functionality.
• Three connectivity components are provided with QuickOPC now: The DAConnectivity (for OPC Data Access), the UAConnectivity (for OPC Unified Architecture), and the CompositeConnectivity (can be configured to contain and combine any number of other connectivity components). The developer will usually start the live binding by dragging one of these connectivity components from the Visual Studio Toolbox to the design surface of the form.
• The PointBinder has just one type of binding – the PointBinding. When you add a point binding, it offers you to select a “point”, which is defined by the connectivity that is attached to the point binder. Consequently, a single “Bind to Point” command is sufficient to bind any control to OPC data. The point can be OPC-DA or OPC-UA point. Inside the PointBinding, the types of parameters, arguments, and operation result, differ based on the type of point.
• The principles of the Live Binding remain the same, and the remainder of the developer’s experience with Live Binding is very similar to the original approach.
• The PointBinding has an UpdateOutputOnFailure property (defaults to ‘false’). Normally, when an operation (such as OPC read) fails, and you are binding to an operation output, nothing happens - the binding output is not updated. For example, a text bound to an OPC data value continues to display the last known value. When the UpdateOutputOnFailure property is set to ‘true’, the binding output will always be updated. In our example, the text box will be cleared in case of operation failure.

Live Binding – Old Project Conversion

This QuickOPC version still supports both the old (DABinder, UABinder) and new (PointBinder with DAConnectivity or UAConnectivity) Live Binding approaches. The DABinder, UABinder and their corresponding binding types are regarded as obsoleted, and may become unsupported or be removed in future versions of QuickOPC. It is therefore strongly recommended that you convert your projects to the new Live Binding approach. We have provided tools and instructions to facilitate the conversion. In order to convert your project that uses the Live Binding to the new approach (assuming that you have QuickOPC 5.35 installed):

1. Make a backup of your project.
2. In Visual Studio, perform the steps below for each of your forms (or custom controls or other components) that use Live Binding.
3. Open the form.
4. If the form uses a DABinder, drag DAConnectivity from the Toolbox to the designer surface. If the form uses UABinder, drag UAConnectivity from the toolbox to the designer surface. Note that a PointBinder component will be added automatically as well.
5. Select (click on) the existing DABinder or UABinder component in the component tray (below the form). In the Properties window (for the DABinder or UABinder component you have selected), invoke the “Convert to point bindings” command. The commands are near the bottom of the property grid. If no commands are displayed, right-click in the left column of the property grid, and enable them from the context menu first.
6. A message box will be displayed, describing the outcome of the conversion. Confirm it by pressing OK. The bindings are binding groups are now converted. Note: Binding groups get new member names.
7. Right-click on the existing DABinder or UABinder component in the component tray (below the form), and delete it (the Delete command).
8. Save the form, build the project, and test it.

Components Core Improvements

• The OperationResult, ValueResult, DAQuality, DAVtq, DAVtqResult, UAAttributeData and UAAttributeDataResult objects now implement IFormattable, making it possible to choose from different formats when displaying the object. Several standard formats (such as G – General, or F – Full) are available. In addition, custom format strings can be used, and custom format specifiers allow picking the desired information from the object and formatting it as needed. Using sections, it is also possible to specify a different format depending on the value – e.g. with DAQuality, one for good quality, and a different one for other cases. The description of various formatting types can be found in the Appendix of the Concepts document.
• The default format for the DAQuality objects, i.e. the result of DAQuality.ToString() method, is now in shorter format, while still providing all necessary information about the quality. The old format can still be achieved by using the “F” (Full, long) format specifier.
• Added ValueType property to OperationResult, DAVtq and UAAttributeData classes. The property returns the type of the value contained in the object, or null if there is no value.

Components Core Refactorings

• Methods UAAttributeData.IsBadStatus(), IsGoodStatus(), IsUncertainStatus() have been turned to read-only properties named HasBadStatus, HasGoodStatus, HasUncertainStatus.
• Method UAAttributeData.HasValue() has been turned to a read-only property.
• Methods UAStatusCode.IsBad(), IsGood(), IsUncertain() have been turned to read-only properties.

OPC “Classic”

• Improved browsing for OPC servers from registry: More information now collected when the server has different bitness than the client.
• Improved speed of OPC server browsing from the registry.

Documentation and Help

• Updated the “Getting Started” and “Concept” documents to reflect the new Live Binding approach with PointBinder, and DAConnectivity, UAConnectivity, or CompositeConnectivity.

Examples

• Added LiveBindingDemo2 project (in C#), showing advanced Live Bindings features. Among others, it demonstrates:
  • Binding kinds: binding to local vs. UTC timestamp.
  • Conversions: Use of LinearConverter, even bi-directionally.
  • Animations: Moving a control around the form, depending on an OPC tag value.
  • Cumulative: Adding incoming values to ListBox or ListView.
• Examples that use Live Binding have been converted to new model (with PointBinder, and DAConnectivity or UAConnectivity).
• Removed a separate solution with Reactive Programming Model examples. The contained project (ReactiveDocExamples) has been moved to the common solution with other C# examples.