Main audience of this page are customers that are seeking to enable their new and existing products with the competitive technology, and need to make decision the software development (SDK) to deliver reliable and secure products, while minimizing the development time and effort.
What are the criteria you should consider when choosing a SDK or toolkit? Here are those that we deem most important:
- Ease of use
- Interoperability with other OPC products
- Compatibility and integration with development tools
- Total cost of ownership
- Documentation, examples, and support
The list below summarizes the benefits QuickOPC brings, in comparison with other available OPC client libraries.
- 1 Support
- 2 Costs
- 3 Lifecycle
- 4 Download
- 5 Getting Started
- 6 Documentation
- 7 Making It Work
- 8 Concepts
- 9 API Design
- 10 Beyond Just API Calls
- 11 Integration with Development Tools
- 12 Developer Friendliness
- 13 Debugging
- 14 Deployment
- 15 Licensing
- 16 Interoperability
- 17 Various Goodies
- 18 Uncategorized
- 💡 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.
- Support is handled by a skilled software developer, with expert knowledge about the product.
- 💡 No need to pay yearly fees to OPC Foundation in order to stay closed-source.
- If you decide to use the "free" code from OPC Foundation, the double-licensing scheme used by their open-sourced code for OPC UA will require 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.
- 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.
- We do not ask for your contact information just because you want to try out our software.
- As opposed to what many other vendors do, anybody can download and play with our software, without having to provide an email address and/or phone number. No forms to fill, no worry that you will end up on salesman's call list.
- You are free to test and evaluate the product before the purchase.
- Out of the box, the product comes with trial license that has *all* features enabled. Upon request, we will issue an evaluation license that also lifts the run-time limitation. You are encouraged to verify that the product is suitable for your purpose, before you buy.
- 💡 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.
- The relevant pieces in the examples are not lost in heaps of irrelevant code.
- We design our examples to be understandable and focus on the job that needs to be done, so that you can pick parts of it and use in your code. For contrast, take the simplest client example from OPC Foundation SDK: It requires you to make a copy of existing Windows Forms project, modify it, run - and then it tells you that all that's needed is in there. Good luck finding it - the whole project is big, and surely there is handful of pieces that do the necessary stuff - but where are they? They are scattered around the files and classes, and nobody tells you where.
- User's Guide
- The extensive conceptual documentation that guides you through QuickOPC usage is available both on-line and as a downloadable and printable PDF document.
- Comprehensive Reference
- All QuickOPC types and methods are thoroughly documented in an online reference documentation. The reference is accompanied with explanatory remarks and examples.
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.
- 💡 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.
- Declarative approach is preferred over imperative.
- The API is designed in such a way that wherever possible, you do not tell the component how to do the work. Instead, you tell it what you want to achieve, and let the software figure out how to do it. For example: With most other libraries, while creating an OPC UA session with proper security settings, you call a method to obtain endpoint descriptions from the server, and then write a code that goes through these descriptions and select the one that you want. With QuickOPC, the component picks the concrete endpoint for you, and if you want to influence that process, you specify the so-called endpoint selection policy, effectively choosing which security settings are acceptable and/or preferrable to you. By the use of various policies and parameters that "declare" what you want, the application code can focus on just the important operations, and leave the rest on the component, or simple configuration. This makes your coding elegant and fast.
- 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.
- Multiple method overloads for short code
- Most QuickOPC methods come with a handful of useful overloads, shortening your code in common cases, and making it easier to understand. You do not have
- Clear error model - makes handling errors a snap.
- QuickOPC clearly tells you which type of exceptions you can expect and should handle, and how. All errors coming from the OPC operations are represented by just two classes. Compare that with e.g. the OPC Foundation SDK code, where there is absolutely no clue as to what kind of exceptions can happen.
- 💡 Low-ceremony API
- QuickOPC gets rid of as much unwanted "ceremonial" code as possible. You do not have to prepare layers of objects and make multiple calls to get the work done. Want to read a value? Call a method and you will get the value back. Compare it with other libraries - for OPC UA, typically you would at least call code to get endpoints from the server, select the right one, maybe create a certificate, connect the session, build a list of values, and only then you can finally call the Read function (and do not forget to tear it all down afterwards, otherwise you end up with leaks).
- Highly intuitive
- One of our design goals is that wherever and whenever possible, things should work "as expected" without you having to study the documentation too much.
- Made for .NET developers
- For .NET, QuickOPC provides an API that is meant for .NET from the very start, and uses the best of it.
- High expressive power
- The API is designed to express the desired operation in a terse manner, and on a high level that combines multiple OPC operations in background automatically, to achieve the desired result.
- Binary and XML serialization
- All relevant QuickOPC objects support standard .NET serialization in binary and XML formats. This means that you do not have to write extra code if you need to persist information such as node IDs in a file, or transfer it to another program.
- Generics and strong typing
- For increased type safety when working with OPC data, you can use extension methods that allow you to specify the type of the data you expect, and are guaranteed to return the correct type only. With this, you do not have to typecast the values, and a faulty OPC server would not be able influence your code negatively. To achieve similar result in languages that do not support generic types, QuickOPC provides extension methods for each of the simple types available.
- Useful .NET methods consistently implemented
- All .NET objects in QuickOPC implement useful standard methods, such as equality support (Equals and GetHashCode) and equality operators. You can therefore easily compare them, store in hash tables and dictionaries, etc.
- .NET and COM interfaces are largely identical
- When you are using a COM-based with QuickOPC, you can reasonable expect that all major objects and their methods are identical with .NET, making it easy to follow the documentation, and also reuse examples from other languages. Only features that are not replicable in COM are omitted or implemented differently.
- Rich set of .NET extension methods
- We consistently make the main set of members on interfaces and objects as small as possible in order to achieve the desired functionality, and then add various argument- and result handling through the use of .NET extension methods. This makes it easier to the developer distinguish between the behavior of the object itself, and everything that has been put "on top" of it.
Beyond Just API Calls
- 💡 User interface - dialogs and controls
- QuickOPC comes with a set of highly configurable dialog components and controls for OPC. They allow the user to perform various forms of discovery and browsing.
- You can animate visual controls without any coding.
- With QuickOPC, you can use a Live Binding development model to connect properties of visual controls with OPC data. This is done in the Visual Studio without any manual coding. You can therefore use Visual Studio to create OPC-enabled HMIs easily.
- Live Mapping
- Similarly to ORM (object-relational mapping) commonly used with databases, QuickOPC allows you to map your objects to OPC data, using its Live Mapping model. And the advantages are also similar: Your code can be shorter and cleaner, because it can work with OPC data as it does with any other data in the program, simply by manipulating properties of objects.
- Excel integration
- If you want to bring the OPC data into Excel, QuickOPC will let you do it without any coding. Its built-in RTD (real-time data) server component integrates with Excel, and allows you to drag-and-drop live OPC data right into Excel cells, or use Excel formulas to read, subscribe, and write OPC data and combine the values in computations.
Integration with Development Tools
- 💡 IntelliSense and Object Browser
- 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, and in its Object Browser.
- 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.
- ReSharper annotations
- Methods, properties and arguments are annotated with ReSharper attributes. This tells you immediately e.g. whether an argument or a result can or cannot be a null reference, and allows ReSharper to perform code checks and indicate possible issues, without giving you falsely positive warnings.
- 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.
- Visual Studio designer and property grid awareness
- Features like descriptions when configuring the objects in Visual Studio, type editors, CodeDOM serialization - all of this works as expected.
- 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.
- This way, you do not need to bother whether the actual underlying OPC function accepts a node ID or browse path, and write extra code to translate between the two. Just use whatever you have available, and QuickOPC will take of picking the right one or making the translation where appropriate. In addition, QuickOPC caches the translations that were already performed, making it very efficient to work with the same nodes later.
- QuickOPC assemblies are also available in form of NuGet packages, for easy dependency management and build automation. The NuGet packages are built by the same automated process as the product installer, and are therefore guaranteed to give identical outcome. In addition, NuGet packages with sample code in C# and VB.NET are also available.
- 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.
- 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 is customized.
- For many objects, QuickOPC does not rely on the default debugger behavior for displaying the values, and provides its own customized display format in the debugger. The format is tailored to the specific object type, for it to contain the most important aspect of the object that the developer needs while debugging - without him having to expand the object and explore its individual properties.
- 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.
- Some objects contain sub-objects, recursively, and the whole hierarchy is difficult to grasp by simply inspecting the properties and sub-properties in the debugger. An example of this are OPC UA complex data values. In such cases, QuickOPC has a DebugView property on the type, providing a user-understandable text representation of the object.
- 💡 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.
- 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.
- 💡 License activation works off-line.
- You do not need Internet connection in order to activate the license (and, you do not need to call or email the vendor, either). Simply install the delivered license key file to the target computer, and no additional "registration" steps are needed.
- Simple license transfer.
- You do not need to deactivate a license on one computer first in order to install it onto a second computer.
- Easy license restoration - no hassles with lost licenses "tied" to a hardware
- Restoration of licenses is easy with QuickOPC. If your hard disk crashes or is accidentally reformatted, there is no "activation counter" that would penalize you. You do not "lose" the license; simply locate the original license key and reinstall it to a new disk or computer.
- Runtime and development license in one
- A single license key enables the product for both runtime and development purposes. No need to keep multiple keys around, no unnecessary cause for confusion.
- 💡 Interoperability tested and proven
- QuickOPC is tested with numerous OPC servers - not just internally, but also with help of external Beta testers. We also regularly visit the so-called OPC Interoperability Workshops for this purpose, and make sure that QuickOPC is compatible with OPC servers on the market and in production. This brings the product to a level which cannot be accomplished just "from the table", and needs years of continuous effort.
- Compliance certified
- QuickOPC has been been officially certified (and re-certified) by OPC Foundation for compliance with OPC specifications. This gives you additional level of confidence that also your own application can be developed as compliant.
- Known OPC server quirks resolved for you
- 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.
- Built on Standards You Trust
- .NET, TCP/IP, ActiveX, COM/DCOM, OLE, XML, SOAP, OPC DA, OPC A&E, OPC UA...
- QuickOPC assemblies have strong names.
- This makes it possible to reference them from other assemblies that are also strong-named, and enabled them to be installed into GAC (Global Assembly Cache) or run under certain CLR hosts. In contrast, for example, OPC Foundation SDK assemblies do not have strong names, forcing you to modify and rebuild them should you need the strong naming.
- Selected objects support .NET custom formatting.
- Objects like VTQ (Value-timestamp-quality) or data change notifications contain multiple heterogenous pieces of data and can be presented in many ways. With other libraries, you are let on your own if you need to format and display them in a way that makes in the context of yoour application. With QuickOPC, there are various standard and configurable custom formats available for display of these objects, making it easy to obtain the desired output.
- Connectivity Explorer
- Use this tool to discover OPC servers, browse their address space, read, subscribe to, and write data - all with friendly user interface. You can also save the item list to an XML file and load it later.
- OPC DA Quality Decoder included
- Do not scramble for OPC specifications when presented with a numerical OPC quality code - just run this little utility, enter the code, and obtain the symbolic representation of the quality fields.