Opc.Ua.Com.Server.ComDaGroup.OnAsyncRead C# (CSharp) Method

        private void OnAsyncRead(object state)
        {
            try
            {
                TraceState("OnAsyncRead");

                // find the request.
                ComDaAsnycReadRequest request = null;
                IComDaGroupCallback callback = null;

                lock (m_lock)
                {
                    // check if dispoed.
                    if (m_disposed)
                    {
                        return;
                    }

                    // find request.
                    for (int ii = 0; ii < m_requests.Count; ii++)
                    {
                        if (Object.ReferenceEquals(state, m_requests[ii]))
                        {
                            request = (ComDaAsnycReadRequest)state;
                            m_requests.RemoveAt(ii);
                            break;
                        }
                    }

                    callback = m_callback;

                    // request must have been cancelled.
                    if (request == null || callback == null)
                    {
                        return;
                    }
                }
                
                // report that the cancel succeeded.
                if (request.Cancelled)
                {
                    callback.CancelSucceeded(m_clientHandle, request.TransactionId);
                    TraceState("OnAsyncRead Cancelled", request.TransactionId, request.CancelId);
                    return;                    
                }
                
                // check if the initial read after group is activated.
                int[] serverHandles = request.ServerHandles;
                List<ComDaGroupItem> itemsToUpdate = null;

                if (request.IsFirstUpdate)
                {
                    lock (m_lock)
                    {
                        // need to check if an update has already arrived.
                        itemsToUpdate = new List<ComDaGroupItem>(m_items.Count);

                        for (int ii = 0; ii < m_items.Count; ii++)
                        {
                            ComDaGroupItem item = m_items[ii];

                            if (item.Active)
                            {
                                itemsToUpdate.Add(item);
                            }
                        }

                        // nothing more to do.
                        if (itemsToUpdate.Count == 0)
                        {
                            return;
                        }

                        // revise the handles to read.
                        serverHandles = new int[itemsToUpdate.Count];

                        for (int ii = 0; ii < itemsToUpdate.Count; ii++)
                        {
                            serverHandles[ii] = itemsToUpdate[ii].ServerHandle;
                        }
                    }
                }

                // read values.
                DaValue[] results = SyncRead(request.MaxAge, serverHandles, request.IsRefresh, null);

                // update cache.
                if (request.IsFirstUpdate)
                {
                    lock (m_lock)
                    {
                        for (int ii = 0; ii < itemsToUpdate.Count; ii++)
                        {
                            ComDaGroupItem item = m_items[ii];
                            item.LastSentValue = results[ii];
                        }
                    }
                }

                // send callback.
                callback.ReadCompleted(
                    this.m_clientHandle,
                    request.IsRefresh,
                    request.CancelId,
                    request.TransactionId,
                    request.ClientHandles,
                    results);

                TraceState("OnAsyncRead Completed", request.TransactionId, request.CancelId);
            }
            catch (Exception e)
            {
                Utils.Trace("Unexpected error during AsyncRead. {0}", e.Message);
            }
        }