Benefits

From OPC Labs Knowledge Base
Jump to navigation Jump to search

Support

  • We respond to every post on our Online Forums (http://www.opclabs.com/forum/index).
  • As opposed to many other vendors, our technical support is public, which means that any possible issues are visible on the Web and you can find them - and an advise on how to resolve them - without having to become a customer first. If your issue involves sensitive or confidential information, we can provide support to you via email.

Costs

>>> No need to pay yearly fees to OPC Foundation in order to stay closed-source.
The double-licensing scheme used by the open-sourced OPC Foundation code for OPC UA requires you to accept the open-source conditions for your own code as well. You can keep your source code closed only if you become an OPC Foundation member ($3,000 yearly minimum). It quickly gets cheaper to purchase the toolkit rather than paying annual OPC Foundation fees.
All QuickOPC commercial licenses are perpetual.
The license you purchase entitles you to use the QuickOPC version(s) for which it is valid perpetually. You do not have to renew it in order to be able to continue using it - we do not use the "subscription" licensing model.

Lifecycle

The product has stable release process.
It is not uncommon to see unexpected, undocumented behavior and content changes between builds of OPC Foundation's software, especially in relation to the installers. QuickOPC only changes between the builds of the same version are for bug fixes. All other modifications only go to a newly released version, and even then the changes are limited and well controlled and documented.

Getting Started

You do not have to create XML configuration files in order to make your program work.
Most other libraries will show you how to write a code, and then tell you it won't actually run, until you also place a specially crafted XML configuration file into your project, *and* also make a change to your app.config file to point to the first XML file. QuickOPC does not require any of that.
Pre-installation of OPC Core Components is not required.
For OPC Classic, QuickOPC does not require you to have the right version OPC Foundation's OPC Core Components installed on the client computer. Other toolkits require that, often resulting in struggle to obtain the version OPC Core Components that works on given computer.
Pre-installation of UA Certificate Generator is not required.
For OPC UA, QuickOPC does not require you to have the right version of OPC Foundation's UA Certificate Generator tool installed on the client computer. With other toolkits, you cannot just write client code, run it and expect it to work - because an OPC UA client needs a certificate to communicate securely, and other SDKs won't generate it for you unless you install the UA Certificate Generator first.
Examples are not just in C#.
The examples that come with QuickOPC cover many different languages, not just C#. Specifically, the second most covered language is VB.NET. Other .NET-based libraries typically come with C# developers in mind only.

Making It Work

No need to create or assign an OPC UA certificate by a manual process.
As opposed to many other tools, QuickOPC will automatically (by default) create an OPC UA certificate for your application and then use it is subsequent runs. You do not have to do anything manually, or in your code, in this respect.
QuickOPC infers the data type in OPC UA writes.
OPC UA is quite picky regarding the data type upon writes, and any difference (such as sending an unsigned integer instead of signed, or simply sending 8 bits instead of 16 or so) results in an error. Other libraries let you on your own, and your code must somehow figure out what the right type is. QuickOPC infers the correct data type, and performs a conversion before the write if necessary, all without you even having to be aware of that.
UA complex data is supported.
QuickOPC understands the custom data type definitions in OPC UA type dictionaries, and decodes and encodes "extension objects" for you. With the OPC Foundation SDK and vast majority of other libraries, all that you are given is a binary "blob", and good luck trying to figure out what it should contain, and writing code that works with it.

Concepts

QuickOPC automatically manages connections and disconnections.
This is one of the most important factors that make QuickOPC unique. The API is designed in such a way that the developer does not setup up or tear down OPC connections. Instead, the code simply performs the true operations that are required (such as read, browse, subscribe), and the library takes care of connections and disconnections automatically. Other libraries require the developer to explicitly manage the connections.
QuickOPC automatically re-connects after failures, and restores the state associated with the connection.
This is particularly important when subscriptions are involved. When an irrecoverable failure occurs while you are subscribed, QuickOPC waits for a configurable period, and then attempts to re-connect. When successful, it also restores all server-side state that was associated with the connection, such as the subscriptions and the items in them. All this is done automatically in background, without you having to write a single line of code. With other libraries, you need to detect the situation yourself, and implement the reconnection logic and state restoration.

API Design

Consistency in various aspects across the product.
If you learn something in one part of the product, you are going to find it implemented analogically elsewhere, too. You do not have to re-learn it over and over, and you will find it easy to locate elements that you are looking for. The consistency is achieved mainly with help of various Conventions. We even went so far that we have automated rules and checks for many of these conventions, so that we can be sure they are consistently applied where they should.
The libraries are CLS-compliant
CLS (Common Language Specification) by Microsoft makes it possible to interact seamlessly with code written in all kinds of .NET-based languages, and that means not just C# (or VB.NET). Other OPC libraries are not CLS compliant.
"Made for .NET"
  • method overloads for short code
  • clear exception model
  • equality/operators
  • Low-ceremony API
  • Highly intuitive toolkit
  • .NET and COM interfaces are largely identical
  • API has high expressive power
  • Binary/xml serialization


Integration with Development Tools

IntelliSense
All QuickOPC types, members and arguments are annotated with XML comments, which means that you will automatically get useful hints through IntelliSense in Visual Studio.
Contextual help in Visual Studio
QuickOPC reference integrates itself into Visual Studio contextual help system. You can obtain detailed help to any QuickOPC element simply by pressing F1.
Components are in VS Toolbox.
QuickOPC client components and user interface controls install themselves automatically into Visual Studio Toolbox (applies to Windows Forms, console and similar projects). This means that you do not even have to write code to instantiate and configure them - you can simply drag them from the toolbox to the designer surface, and Visual Studio will create the code for you.

Developer Friendliness

Debugging

QuickOPC adjusts the OPC UA keep-alive timing in debugger.
OPC UA has built-in mechanisms that monitor the client-server connection for liveliness. That is good in production, but it also means that when you put a breakpoint into an OPC UA program, you are likely to encounter a broken connection when you resume the execution - because there was no communication while the program was paused. Other toolkits ignore this issue; QuickOPC detects the debugger, and attempts to adjust the parameters so that the execution can be paused for extended periods of time.
debugger display customized
Unnecessary private fields are hidden in the debugger.
QuickOPC types are annotated so that you only see the relevant properties and fields in the debugger. You are not bothered with internal information that is not useful to you. (This is work in progress as of QuickOPC 2018.1.)
Special DebugView property to visualize complex types.

Deployment

The deployment elements are clearly described in the documentation, and the deployment process is straightforward.
You do not have to do trial-and-error in order to figure out what to deploy and how. Just follow the documentation. In most cases, the deployment consists just of including the QuickOPC assemblied with your program, and installing the license.
Installer that actually works.
QuickOPC comes with a production installer that can be used to only install the parts that are necessary in run-time. The installer installs files into a well documented and controllable directory (as opposed to OPC Foundation's installer that installs files to undocumented directories that the user cannot control, but does not install anything into the directory the user enters...).
The QuickOPC installable and all binaries are code-signed.
Some environments do not allow any deploying any unsigned code, for security reasons (and it is a good advice to always use code signing anyway). OPC Foundation libraries are not code signed; same applies to some other toolkits.

Licensing

Simple licensing - no hassles with lost licenses "tied" to a hardware

Interoperability

Interoperability tested
Compliance certified
Known OPC server quirks resolved
During interoperability testing, we encounter OPC servers that do not behave as they should. QuickOPC strives to achieve best interoperability in this case, too. Instead of having the operation failed because of faulty server implementation, QuickOPC attempts tor recognize the situation and work around it. We even have special code inside the library to handle such servers. This way, you can largely forget about these special quirks, and everything appears "as normal" to you as a developer.

Various Goodies

  • formatting feature
  • assemblies have strong names
  • OPC DA Quality Decoder included

Uncategorized

  • connectivity explorer
  • Comprehensive Reference
  • Visual binding


  • Typesafe (strong typing)/generics
  • Excel integration
You can specify namespace URIs for OPC UA nodes
... and not namespaces indices. This is important, because the server can can change namespace indices between sessions. Other toolkits largely ignore this, and even give you examples where the node is specified with a hard-coded namespace index. Proper way of doing this is to look up the namespace index that corresponds to namespace URI, but that complicates the user code a lot. QuickOPC does this for you.
any node/item descriptor can specify either a node ID, or browse path, or both
NuGet
Deployment of applications is easy and fully documented.
QuickOPC has only very few requirements on the target system (such as the presence of the .NET Framework), but the dependencies it has are clearly stated in a dedicated section of the User's Guide, and explained.
OPC XML-DA servers are accessible through the same component as OPC DA.
With QuickOPC, the same component and API is used to work with "Classic" OPC DA Servers, as with the OPC XML-DA Servers. Just use the URL in place of server's ProgID, and your code can work with XML-DA. Other libraries require you to write different code for OPC XML-DA versus OPC-DA.
Retrieved from "https://kb.opclabs.com/index.php?title=Benefits&oldid=1601"