Thank you for the additional information.

"Web application" is quite a broad term, so when giving recommendations, I need to qualify that with which approach is used to make them.

One common scenario is that OPC data are needed when the page is generated. And, the page request may come either "randomly" (based on how the users navigate through the app), or periodically (enforced page refresh and other approaches). For this scenario, EasyDAClient has two main features: 1) It keeps the OPC connection open for a configurable time between the requests, and 2) it observes the pattern of "read" calls, and sets up an additional OPC subscription, in an attempt to have the data already available when the request comes (and not having to do the actual OPC Read).

The above two features generally do improve the performance, but also bring in the timing "instability" that you have observed, because inevitable fluctuations (or simply randomness) in the rate of page requests cause different behavior depending on whether the data momentary available is "fresh enough" or not. It is possibly to disable this (one part of it is to specify the reading from Device or Cache and not by ValueAge) - the result is more predictability in terms of timing, but most likely slower performance on average. See also www.opclabs.com/forum/reading-writing-subscriptions-property...scriptions-made-with-opc-reads .

If the application needs to "observe" values of certain tags for extended periods of time, *and* you can set up objects that run on a global scope (not per page request), then it is generally wiser to use OPC subscriptions on this global scope, and store the incoming values (from easyDAClient, they arrive through events or callbacks) into some data structure. The page code can then just pick up the latest data values from this data structure, without further calls to OPC or even EasyDAClient. Implementing this requires some extra care (such as synchronizing the access to the shared data structure), but for some applications it is really the best approach.

Thank you for details. As a general note, if the intent is to obtain the latest values over a longer time, it is far better to use the subscriptions (although, in a Web application, that might get complicated - I know).

How often do you perform this code? Is it on a regular basis (if so, what is the rate of execution), or is it inside a page rendering code, and you cannot predict when the request is made? The reason I am asking is because we hold the connection to the server for some time. When the next request is done during certain time, the connection is reused. Otherwise, it has to be re-established.

The other thing to consider are the read parameters. You can specify to read from Device, from Cache, or (dynamically determine the source) by ValueAge. The Device is always slowest. The default is to read by ValueAge of 1000 milliseconds, meaning that depending on when the last value of read, you could get a value "from memory", or the device has to be contacted.

Modbus (serial) is generally relatively slow. With ReadItem or ReadMultipleItems, we do not do different processing (on the client side) based on the data Quality. Therefore, if tags with Bad quality take more time, the reason must be on the server side (and may be perfectly OK when reading from Device is involved).

Thanks for describing what you have done so far and the results. Instead of giving you a whole bunch of recommendations at once, I suggest we do it interactively - I'll ask a few questions and then reply based on your answers.

1. What is are the primary methods you are using on EasyDAClient?
"Single-shot" operations (ReadXXXX, WriteXXXX), or are you using SubscribeXXXX?

2. How many tags are we talking about?

3. Are you calling the methods on EasyDAClient for them in a loop, or do you use a method with "Multiple" in its name?

4. If you are doing a "single-shot" Read, is it a method that returns just a value (ReadItemValue, ReadMultipleItemValues), or a method that returns a whole VTQ (ReadItem, ReadMultipleItems?)

Thank you