/// <summary>
/// Sends an asynchronous request to read item values that have been deleted or replaced.
/// </summary>
/// <param name="startTime">The beginning of the history period to read.</param>
/// <param name="endTime">The end of the history period to be read.</param>
/// <param name="maxValues">The number of values to be read for each item.</param>
/// <param name="items">The set of items to read (must include the server handle).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
public IdentifiedResult[] ReadModified(
Time startTime,
Time endTime,
int maxValues,
ItemIdentifier[] items,
object requestHandle,
ReadValuesEventHandler callback,
out IRequest request)
{
if (m_server == null)
{
throw new NotConnectedException();
}
IdentifiedResult[] results = ((IServer)m_server).ReadModified(
startTime,
endTime,
maxValues,
items,
requestHandle,
callback,
out request);
return(results);
}
/// <summary>
/// Sends an asynchronous request to read processed data from the historian database for a set of items.
/// </summary>
/// <param name="startTime">The beginning of the history period to read.</param>
/// <param name="endTime">The end of the history period to be read.</param>
/// <param name="resampleInterval">The interval between returned values.</param>
/// <param name="items">The set of items to read (must include the server handle).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
public IdentifiedResult[] ReadProcessed(
Time startTime,
Time endTime,
decimal resampleInterval,
Item[] items,
object requestHandle,
ReadValuesEventHandler callback,
out IRequest request)
{
if (m_server == null)
{
throw new NotConnectedException();
}
IdentifiedResult[] results = ((IServer)m_server).ReadProcessed(
startTime,
endTime,
resampleInterval,
items,
requestHandle,
callback,
out request);
return(results);
}
/// <summary>
/// Invokes callback for a read request.
/// </summary>
private bool InvokeCallback(ReadValuesEventHandler callback, object results)
{
// check for valid result type.
if (!typeof(ItemValueCollection[]).IsInstanceOfType(results))
{
return(false);
}
ItemValueCollection[] values = (ItemValueCollection[])results;
// update item handles and actual times.
UpdateResults(values);
try
{
callback(this, values);
}
catch
{
// ignore exceptions in the callbacks.
}
// check if all data has been sent.
foreach (ItemValueCollection value in values)
{
if (value.ResultID == ResultID.Hda.S_MOREDATA)
{
return(false);
}
}
// request is complete.
return(true);
}
/// <summary>
/// Starts an asynchronous read values at specific times request for all items in the trend.
/// </summary>
public IdentifiedResult[] ReadAtTime(
object requestHandle,
ReadValuesEventHandler callback,
out IRequest request)
{
return(ReadAtTime(GetItems(), requestHandle, callback, out request));
}
public IdentifiedResult[] Read(Item[] items, object requestHandle, ReadValuesEventHandler callback, out IRequest request)
{
if (this.AggregateID == 0)
{
return(this.ReadRaw(items, requestHandle, callback, out request));
}
return(this.ReadProcessed(items, requestHandle, callback, out request));
}
public IdentifiedResult[] ReadAtTime(Item[] items, object requestHandle, ReadValuesEventHandler callback, out IRequest request)
{
DateTime[] timestamps = new DateTime[this.Timestamps.Count];
for (int i = 0; i < this.Timestamps.Count; i++)
{
timestamps[i] = this.Timestamps[i];
}
return(this.m_server.ReadAtTime(timestamps, items, requestHandle, callback, out request));
}
/// <summary>
/// Sends an asynchronous request to read raw data from the historian database for a set of items.
/// </summary>
/// <param name="startTime">The beginning of the history period to read.</param>
/// <param name="endTime">The end of the history period to be read.</param>
/// <param name="maxValues">The number of values to be read for each item.</param>
/// <param name="includeBounds">Whether the bounding item values should be returned.</param>
/// <param name="items">The set of items to read (must include the server handle).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
public IdentifiedResult[] ReadRaw(
Time startTime,
Time endTime,
int maxValues,
bool includeBounds,
ItemIdentifier[] items,
object requestHandle,
ReadValuesEventHandler callback,
out IRequest request)
{
if (m_server == null)
{
throw new NotConnectedException();
}
return(((IServer)m_server).ReadRaw(startTime, endTime, maxValues, includeBounds, items, requestHandle, callback, out request));
}
/// <summary>
/// Starts an asynchronous read modified request for a set of items.
/// </summary>
public IdentifiedResult[] ReadModified(
Item[] items,
object requestHandle,
ReadValuesEventHandler callback,
out IRequest request)
{
IdentifiedResult[] results = m_server.ReadModified(
StartTime,
EndTime,
MaxValues,
items,
requestHandle,
callback,
out request);
return(results);
}
/// <summary>
/// Starts an asynchronous read request for a set of items.
/// </summary>
public IdentifiedResult[] Read(
Item[] items,
object requestHandle,
ReadValuesEventHandler callback,
out IRequest request)
{
// read raw data.
if (AggregateID == Opc.Hda.AggregateID.NOAGGREGATE)
{
return(ReadRaw(items, requestHandle, callback, out request));
}
// read processed data.
else
{
return(ReadProcessed(items, requestHandle, callback, out request));
}
}
/// <summary>
/// Starts an asynchronous read processed request for a set of items.
/// </summary>
public IdentifiedResult[] ReadProcessed(
Item[] items,
object requestHandle,
ReadValuesEventHandler callback,
out IRequest request)
{
Item[] localItems = ApplyDefaultAggregate(items);
IdentifiedResult[] results = m_server.ReadProcessed(
StartTime,
EndTime,
ResampleInterval,
localItems,
requestHandle,
callback,
out request);
return(results);
}
/// <summary>
/// Sends an asynchronous request to read item values at specific times.
/// </summary>
/// <param name="timestamps">The set of timestamps to use when reading items values.</param>
/// <param name="items">The set of items to read (must include the server handle).</param>
/// <param name="requestHandle">An identifier for the request assigned by the caller.</param>
/// <param name="callback">A delegate used to receive notifications when the request completes.</param>
/// <param name="request">An object that contains the state of the request (used to cancel the request).</param>
/// <returns>A set of results containing any errors encountered when the server validated the items.</returns>
public IdentifiedResult[] ReadAtTime(
DateTime[] timestamps,
ItemIdentifier[] items,
object requestHandle,
ReadValuesEventHandler callback,
out IRequest request)
{
if (m_server == null)
{
throw new NotConnectedException();
}
IdentifiedResult[] results = ((IServer)m_server).ReadAtTime(
timestamps,
items,
requestHandle,
callback,
out request);
return(results);
}
private bool InvokeCallback(ReadValuesEventHandler callback, object results)
{
if (!typeof(ItemValueCollection[]).IsInstanceOfType(results))
{
return(false);
}
ItemValueCollection[] valuesArray = (ItemValueCollection[])results;
this.UpdateResults(valuesArray);
try
{
callback(this, valuesArray);
}
catch
{
}
foreach (ItemValueCollection values in valuesArray)
{
if (values.ResultID == ResultID.Hda.S_MOREDATA)
{
return(false);
}
}
return(true);
}
public IdentifiedResult[] ReadRaw(ItemIdentifier[] items, object requestHandle, ReadValuesEventHandler callback, out IRequest request)
{
return(this.m_server.ReadRaw(this.StartTime, this.EndTime, this.MaxValues, this.IncludeBounds, items, requestHandle, callback, out request));
}
public IdentifiedResult[] ReadRaw(object requestHandle, ReadValuesEventHandler callback, out IRequest request)
{
return(this.Read(this.GetItems(), requestHandle, callback, out request));
}
public IdentifiedResult[] ReadProcessed(Item[] items, object requestHandle, ReadValuesEventHandler callback, out IRequest request)
{
Item[] itemArray = this.ApplyDefaultAggregate(items);
return(this.m_server.ReadProcessed(this.StartTime, this.EndTime, this.ResampleInterval, itemArray, requestHandle, callback, out request));
}
public IdentifiedResult[] ReadModified(Item[] items, object requestHandle, ReadValuesEventHandler callback, out IRequest request)
{
return(this.m_server.ReadModified(this.StartTime, this.EndTime, this.MaxValues, items, requestHandle, callback, out request));
}
public IdentifiedResult[] ReadAtTime(DateTime[] timestamps, ItemIdentifier[] items, object requestHandle, ReadValuesEventHandler callback, out IRequest request)
{
if (base.m_server == null)
{
throw new NotConnectedException();
}
return(((Opc.Hda.IServer)base.m_server).ReadAtTime(timestamps, items, requestHandle, callback, out request));
}
