661 lines
25 KiB
C#
661 lines
25 KiB
C#
#region Copyright (c) 2011-2023 Technosoftware GmbH. All rights reserved
|
|
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 2011-2023 Technosoftware GmbH. All rights reserved
|
|
// Web: https://www.technosoftware.com
|
|
//
|
|
// The source code in this file is covered under a dual-license scenario:
|
|
// - Owner of a purchased license: SCLA 1.0
|
|
// - GPL V3: everybody else
|
|
//
|
|
// SCLA license terms accompanied with this source code.
|
|
// See SCLA 1.0: https://technosoftware.com/license/Source_Code_License_Agreement.pdf
|
|
//
|
|
// GNU General Public License as published by the Free Software Foundation;
|
|
// version 3 of the License are accompanied with this source code.
|
|
// See https://technosoftware.com/license/GPLv3License.txt
|
|
//
|
|
// This source code is distributed in the hope that it will be useful, but
|
|
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
// or FITNESS FOR A PARTICULAR PURPOSE.
|
|
//-----------------------------------------------------------------------------
|
|
#endregion Copyright (c) 2011-2023 Technosoftware GmbH. All rights reserved
|
|
|
|
#region Using Directives
|
|
|
|
using System;
|
|
using System.Runtime.Serialization;
|
|
#endregion
|
|
|
|
namespace Technosoftware.DaAeHdaClient.Ae
|
|
{
|
|
/// <summary>
|
|
/// An in-process object which provides access to AE server objects.
|
|
/// </summary>
|
|
[Serializable]
|
|
public class TsCAeServer : OpcServer, ITsCAeServer
|
|
{
|
|
#region SubscriptionCollection Class
|
|
/// <summary>
|
|
/// A read-only collection of subscriptions.
|
|
/// </summary>
|
|
public class SubscriptionCollection : OpcReadOnlyCollection
|
|
{
|
|
#region Constructors, Destructor, Initialization
|
|
/// <summary>
|
|
/// Creates an empty collection.
|
|
/// </summary>
|
|
internal SubscriptionCollection() : base(new TsCAeSubscription[0]) { }
|
|
#endregion
|
|
|
|
#region Public Methods
|
|
/// <summary>
|
|
/// An indexer for the collection.
|
|
/// </summary>
|
|
public new TsCAeSubscription this[int index] => (TsCAeSubscription)Array.GetValue(index);
|
|
|
|
/// <summary>
|
|
/// Returns a copy of the collection as an array.
|
|
/// </summary>
|
|
public new TsCAeSubscription[] ToArray()
|
|
{
|
|
return (TsCAeSubscription[])Array;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds a subscription to the end of the collection.
|
|
/// </summary>
|
|
internal void Add(TsCAeSubscription subscription)
|
|
{
|
|
var array = new TsCAeSubscription[Count + 1];
|
|
|
|
Array.CopyTo(array, 0);
|
|
array[Count] = subscription;
|
|
|
|
Array = array;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes a subscription to the from the collection.
|
|
/// </summary>
|
|
internal void Remove(TsCAeSubscription subscription)
|
|
{
|
|
var array = new TsCAeSubscription[Count - 1];
|
|
|
|
var index = 0;
|
|
|
|
for (var ii = 0; ii < Array.Length; ii++)
|
|
{
|
|
var element = (TsCAeSubscription)Array.GetValue(ii);
|
|
|
|
if (subscription != element)
|
|
{
|
|
array[index++] = element;
|
|
}
|
|
}
|
|
|
|
Array = array;
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
#region Names Class
|
|
/// <summary>
|
|
/// A set of names for fields used in serialization.
|
|
/// </summary>
|
|
private class Names
|
|
{
|
|
internal const string Count = "CT";
|
|
internal const string Subscription = "SU";
|
|
}
|
|
#endregion
|
|
|
|
#region Fields
|
|
private int filters_;
|
|
private bool disposing_;
|
|
private SubscriptionCollection subscriptions_ = new SubscriptionCollection();
|
|
#endregion
|
|
|
|
#region Constructors, Destructor, Initialization
|
|
/// <summary>
|
|
/// Initializes the object with a factory and a default OpcUrl.
|
|
/// </summary>
|
|
/// <param name="factory">The OpcFactory used to connect to remote servers.</param>
|
|
/// <param name="url">The network address of a remote server.</param>
|
|
public TsCAeServer(OpcFactory factory, OpcUrl url)
|
|
: base(factory, url)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructs a server by de-serializing its OpcUrl from the stream.
|
|
/// </summary>
|
|
protected TsCAeServer(SerializationInfo info, StreamingContext context)
|
|
:
|
|
base(info, context)
|
|
{
|
|
var count = (int)info.GetValue(Names.Count, typeof(int));
|
|
|
|
subscriptions_ = new SubscriptionCollection();
|
|
|
|
for (var ii = 0; ii < count; ii++)
|
|
{
|
|
var subscription = (TsCAeSubscription)info.GetValue(Names.Subscription + ii, typeof(TsCAeSubscription));
|
|
subscriptions_.Add(subscription);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Properties
|
|
/// <summary>
|
|
/// The filters supported by the server.
|
|
/// </summary>
|
|
// ReSharper disable once UnusedMember.Global
|
|
public int AvailableFilters => filters_;
|
|
|
|
/// <summary>
|
|
/// The outstanding subscriptions for the server.
|
|
/// </summary>
|
|
public SubscriptionCollection Subscriptions => subscriptions_;
|
|
#endregion
|
|
|
|
#region Public Methods
|
|
/// <summary>
|
|
/// Connects to the server with the specified OpcUrl and credentials.
|
|
/// </summary>
|
|
public override void Connect(OpcUrl url, OpcConnectData connectData)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
// connect to server.
|
|
base.Connect(url, connectData);
|
|
|
|
// all done if no subscriptions.
|
|
if (subscriptions_.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// create subscriptions (should only happen if server has been deserialized).
|
|
var subscriptions = new SubscriptionCollection();
|
|
|
|
foreach (TsCAeSubscription template in subscriptions_)
|
|
{
|
|
// create subscription for template.
|
|
try { subscriptions.Add(EstablishSubscription(template)); }
|
|
catch
|
|
{
|
|
// ignored
|
|
}
|
|
}
|
|
|
|
// save new set of subscriptions.
|
|
subscriptions_ = subscriptions;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Disconnects from the server and releases all network resources.
|
|
/// </summary>
|
|
public override void Disconnect()
|
|
{
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
// dispose of all subscriptions first.
|
|
disposing_ = true;
|
|
|
|
foreach (TsCAeSubscription subscription in subscriptions_)
|
|
{
|
|
subscription.Dispose();
|
|
}
|
|
|
|
disposing_ = false;
|
|
|
|
// disconnect from server.
|
|
base.Disconnect();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the current server status.
|
|
/// </summary>
|
|
/// <returns>The current server status.</returns>
|
|
public OpcServerStatus GetServerStatus()
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
var status = ((ITsCAeServer)Server).GetServerStatus();
|
|
|
|
if (status != null)
|
|
{
|
|
if (status.StatusInfo == null)
|
|
{
|
|
status.StatusInfo = GetString($"serverState.{status.ServerState}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (Server == null) throw new NotConnectedException();
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a new event subscription.
|
|
/// </summary>
|
|
/// <param name="state">The initial state for the subscription.</param>
|
|
/// <returns>The new subscription object.</returns>
|
|
public ITsCAeSubscription CreateSubscription(TsCAeSubscriptionState state)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
// create remote object.
|
|
var subscription = ((ITsCAeServer)Server).CreateSubscription(state);
|
|
|
|
if (subscription != null)
|
|
{
|
|
// create wrapper.
|
|
var wrapper = new TsCAeSubscription(this, subscription, state);
|
|
subscriptions_.Add(wrapper);
|
|
return wrapper;
|
|
}
|
|
|
|
// should never happen.
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the event filters supported by the server.
|
|
/// </summary>
|
|
/// <returns>A bit mask of all event filters supported by the server.</returns>
|
|
public int QueryAvailableFilters()
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
filters_ = ((ITsCAeServer)Server).QueryAvailableFilters();
|
|
|
|
return filters_;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the event categories supported by the server for the specified event types.
|
|
/// </summary>
|
|
/// <param name="eventType">A bit mask for the event types of interest.</param>
|
|
/// <returns>A collection of event categories.</returns>
|
|
public TsCAeCategory[] QueryEventCategories(int eventType)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
// fetch categories from server.
|
|
var categories = ((ITsCAeServer)Server).QueryEventCategories(eventType);
|
|
|
|
// return result.
|
|
return categories;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the condition names supported by the server for the specified event categories.
|
|
/// </summary>
|
|
/// <param name="eventCategory">A bit mask for the event categories of interest.</param>
|
|
/// <returns>A list of condition names.</returns>
|
|
public string[] QueryConditionNames(int eventCategory)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
// fetch condition names from the server.
|
|
var conditions = ((ITsCAeServer)Server).QueryConditionNames(eventCategory);
|
|
|
|
// return result.
|
|
return conditions;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the sub-condition names supported by the server for the specified event condition.
|
|
/// </summary>
|
|
/// <param name="conditionName">The name of the condition.</param>
|
|
/// <returns>A list of sub-condition names.</returns>
|
|
public string[] QuerySubConditionNames(string conditionName)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
// fetch sub-condition names from the server.
|
|
var subConditions = ((ITsCAeServer)Server).QuerySubConditionNames(conditionName);
|
|
|
|
// return result.
|
|
return subConditions;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the condition names supported by the server for the specified event source.
|
|
/// </summary>
|
|
/// <param name="sourceName">The name of the event source.</param>
|
|
/// <returns>A list of condition names.</returns>
|
|
public string[] QueryConditionNames(string sourceName)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
// fetch condition names from the server.
|
|
var conditions = ((ITsCAeServer)Server).QueryConditionNames(sourceName);
|
|
|
|
// return result.
|
|
return conditions;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the event attributes supported by the server for the specified event categories.
|
|
/// </summary>
|
|
/// <param name="eventCategory">A bit mask for the event categories of interest.</param>
|
|
/// <returns>A collection of event attributes.</returns>
|
|
public TsCAeAttribute[] QueryEventAttributes(int eventCategory)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
// fetch attributes from server.
|
|
var attributes = ((ITsCAeServer)Server).QueryEventAttributes(eventCategory);
|
|
|
|
// return result.
|
|
return attributes;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the DA item ids for a set of attribute ids belonging to events which meet the specified filter criteria.
|
|
/// </summary>
|
|
/// <param name="sourceName">The event source of interest.</param>
|
|
/// <param name="eventCategory">The id of the event category for the events of interest.</param>
|
|
/// <param name="conditionName">The name of a condition within the event category.</param>
|
|
/// <param name="subConditionName">The name of a sub-condition within a multi-state condition.</param>
|
|
/// <param name="attributeIDs">The ids of the attributes to return item ids for.</param>
|
|
/// <returns>A list of item urls for each specified attribute.</returns>
|
|
public TsCAeItemUrl[] TranslateToItemIDs(
|
|
string sourceName,
|
|
int eventCategory,
|
|
string conditionName,
|
|
string subConditionName,
|
|
int[] attributeIDs)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
var itemUrls = ((ITsCAeServer)Server).TranslateToItemIDs(
|
|
sourceName,
|
|
eventCategory,
|
|
conditionName,
|
|
subConditionName,
|
|
attributeIDs);
|
|
|
|
return itemUrls;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the current state information for the condition instance corresponding to the source and condition name.
|
|
/// </summary>
|
|
/// <param name="sourceName">The source name</param>
|
|
/// <param name="conditionName">A condition name for the source.</param>
|
|
/// <param name="attributeIDs">The list of attributes to return with the condition state.</param>
|
|
/// <returns>The current state of the connection.</returns>
|
|
public TsCAeCondition GetConditionState(
|
|
string sourceName,
|
|
string conditionName,
|
|
int[] attributeIDs)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
var condition = ((ITsCAeServer)Server).GetConditionState(sourceName, conditionName, attributeIDs);
|
|
|
|
return condition;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Places the specified process areas into the enabled state.
|
|
/// </summary>
|
|
/// <param name="areas">A list of fully qualified area names.</param>
|
|
/// <returns>The results of the operation for each area.</returns>
|
|
public OpcResult[] EnableConditionByArea(string[] areas)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
var results = ((ITsCAeServer)Server).EnableConditionByArea(areas);
|
|
|
|
return results;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Places the specified process areas into the disabled state.
|
|
/// </summary>
|
|
/// <param name="areas">A list of fully qualified area names.</param>
|
|
/// <returns>The results of the operation for each area.</returns>
|
|
public OpcResult[] DisableConditionByArea(string[] areas)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
var results = ((ITsCAeServer)Server).DisableConditionByArea(areas);
|
|
|
|
return results;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Places the specified process areas into the enabled state.
|
|
/// </summary>
|
|
/// <param name="sources">A list of fully qualified source names.</param>
|
|
/// <returns>The results of the operation for each area.</returns>
|
|
public OpcResult[] EnableConditionBySource(string[] sources)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
var results = ((ITsCAeServer)Server).EnableConditionBySource(sources);
|
|
|
|
return results;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Places the specified process areas into the disabled state.
|
|
/// </summary>
|
|
/// <param name="sources">A list of fully qualified source names.</param>
|
|
/// <returns>The results of the operation for each area.</returns>
|
|
public OpcResult[] DisableConditionBySource(string[] sources)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
var results = ((ITsCAeServer)Server).DisableConditionBySource(sources);
|
|
|
|
return results;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the enabled state for the specified process areas.
|
|
/// </summary>
|
|
/// <param name="areas">A list of fully qualified area names.</param>
|
|
public TsCAeEnabledStateResult[] GetEnableStateByArea(string[] areas)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
var results = ((ITsCAeServer)Server).GetEnableStateByArea(areas);
|
|
|
|
return results;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the enabled state for the specified event sources.
|
|
/// </summary>
|
|
/// <param name="sources">A list of fully qualified source names.</param>
|
|
public TsCAeEnabledStateResult[] GetEnableStateBySource(string[] sources)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
var results = ((ITsCAeServer)Server).GetEnableStateBySource(sources);
|
|
|
|
return results;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Used to acknowledge one or more conditions in the event server.
|
|
/// </summary>
|
|
/// <param name="acknowledgmentId">The identifier for who is acknowledging the condition.</param>
|
|
/// <param name="comment">A comment associated with the acknowledgment.</param>
|
|
/// <param name="conditions">The conditions being acknowledged.</param>
|
|
/// <returns>A list of result id indicating whether each condition was successfully acknowledged.</returns>
|
|
public OpcResult[] AcknowledgeCondition(
|
|
string acknowledgmentId,
|
|
string comment,
|
|
TsCAeEventAcknowledgement[] conditions)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
return ((ITsCAeServer)Server).AcknowledgeCondition(acknowledgmentId, comment, conditions);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Browses for all children of the specified area that meet the filter criteria.
|
|
/// </summary>
|
|
/// <param name="areaId">The full-qualified id for the area.</param>
|
|
/// <param name="browseType">The type of children to return.</param>
|
|
/// <param name="browseFilter">The expression used to filter the names of children returned.</param>
|
|
/// <returns>The set of elements that meet the filter criteria.</returns>
|
|
public TsCAeBrowseElement[] Browse(
|
|
string areaId,
|
|
TsCAeBrowseType browseType,
|
|
string browseFilter)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
return ((ITsCAeServer)Server).Browse(areaId, browseType, browseFilter);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Browses for all children of the specified area that meet the filter criteria.
|
|
/// </summary>
|
|
/// <param name="areaId">The full-qualified id for the area.</param>
|
|
/// <param name="browseType">The type of children to return.</param>
|
|
/// <param name="browseFilter">The expression used to filter the names of children returned.</param>
|
|
/// <param name="maxElements">The maximum number of elements to return.</param>
|
|
/// <param name="position">The object used to continue the browse if the number nodes exceeds the maximum specified.</param>
|
|
/// <returns>The set of elements that meet the filter criteria.</returns>
|
|
public TsCAeBrowseElement[] Browse(
|
|
string areaId,
|
|
TsCAeBrowseType browseType,
|
|
string browseFilter,
|
|
int maxElements,
|
|
out IOpcBrowsePosition position)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
return ((ITsCAeServer)Server).Browse(areaId, browseType, browseFilter, maxElements, out position);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Continues browsing the server's address space at the specified position.
|
|
/// </summary>
|
|
/// <param name="maxElements">The maximum number of elements to return.</param>
|
|
/// <param name="position">The position object used to continue a browse operation.</param>
|
|
/// <returns>The set of elements that meet the filter criteria.</returns>
|
|
public TsCAeBrowseElement[] BrowseNext(int maxElements, ref IOpcBrowsePosition position)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (Server == null) throw new NotConnectedException();
|
|
|
|
return ((ITsCAeServer)Server).BrowseNext(maxElements, ref position);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ISerializable Members
|
|
|
|
/// <summary>
|
|
/// Serializes a server into a stream.
|
|
/// </summary>
|
|
public override void GetObjectData(SerializationInfo info, StreamingContext context)
|
|
{
|
|
base.GetObjectData(info, context);
|
|
|
|
info.AddValue(Names.Count, subscriptions_.Count);
|
|
|
|
for (var ii = 0; ii < subscriptions_.Count; ii++)
|
|
{
|
|
info.AddValue(Names.Subscription + ii, subscriptions_[ii]);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private Methods
|
|
|
|
/// <summary>
|
|
/// Called when a subscription object is disposed.
|
|
/// </summary>
|
|
/// <param name="subscription"></param>
|
|
internal void SubscriptionDisposed(TsCAeSubscription subscription)
|
|
{
|
|
if (!disposing_)
|
|
{
|
|
subscriptions_.Remove(subscription);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Establishes a subscription based on the template provided.
|
|
/// </summary>
|
|
private TsCAeSubscription EstablishSubscription(TsCAeSubscription template)
|
|
{
|
|
ITsCAeSubscription remoteServer = null;
|
|
|
|
try
|
|
{
|
|
// create remote object.
|
|
remoteServer = ((ITsCAeServer)Server).CreateSubscription(template.State);
|
|
|
|
if (remoteServer == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// create wrapper.
|
|
var subscription = new TsCAeSubscription(this, remoteServer, template.State);
|
|
|
|
// set filters.
|
|
subscription.SetFilters(template.Filters);
|
|
|
|
// set attributes.
|
|
var enumerator = template.Attributes.GetEnumerator();
|
|
|
|
while (enumerator.MoveNext())
|
|
{
|
|
if (enumerator.Key != null)
|
|
subscription.SelectReturnedAttributes(
|
|
(int)enumerator.Key,
|
|
((TsCAeSubscription.AttributeCollection)enumerator.Value).ToArray());
|
|
}
|
|
|
|
// return new subscription
|
|
return subscription;
|
|
}
|
|
catch
|
|
{
|
|
if (remoteServer != null)
|
|
{
|
|
remoteServer.Dispose();
|
|
}
|
|
}
|
|
|
|
// return null.
|
|
return null;
|
|
}
|
|
#endregion
|
|
}
|
|
}
|