public static IDisposable WriteValues(this IValueSymbol symbol, IObservable <object> valueObservable)
{
Action <Exception> errorHandler = delegate(Exception ex) {
};
return(symbol.WriteValues(valueObservable, errorHandler));
}
public static IObservable <SymbolNotification> WhenNotification(this IAdsConnection client, ISymbolCollection symbols, NotificationSettings settings)
{
if (symbols == null)
{
throw new ArgumentNullException("symbols");
}
ISymbol local1 = Enumerable.FirstOrDefault <ISymbol>(symbols);
if (local1 == null)
{
throw new ArgumentOutOfRangeException("Symbols list is empty!", "symbols");
}
IValueSymbol symbol = local1 as IValueSymbol;
if (symbol == null)
{
throw new ArgumentOutOfRangeException("Symbols in list are not IValueSymbol", "symbols");
}
IAccessorValueFactory valueFactory = symbol.ValueAccessor.ValueFactory;
IDisposableSymbolHandleBag bag = null;
object userData = new object();
return(Observable.Where <SymbolNotification>(Observable.Select <EventPattern <AdsNotificationEventArgs>, SymbolNotification>(Observable.Where <EventPattern <AdsNotificationEventArgs> >(Observable.FromEventPattern <AdsNotificationEventHandler, AdsNotificationEventArgs>(delegate(AdsNotificationEventHandler h) {
client.AdsNotification += h;
bag = new DisposableNotificationHandleBag(client, symbols, settings, userData);
}, delegate(AdsNotificationEventHandler h) {
bag.Dispose();
bag = null;
client.AdsNotification -= h;
}), ev => bag.Contains((uint)ev.get_EventArgs().NotificationHandle)), ev => new SymbolNotification(ev.get_EventArgs(), bag.GetSymbol((uint)ev.get_EventArgs().NotificationHandle), valueFactory)), s => symbols.Contains(s.Symbol)));
}
/// <summary>
/// Reads ADS Array Symbol value(s) into instance of type T[].
/// </summary>
/// <typeparam name="T">Type (class or struct Array definition)</typeparam>
/// <param name="Symbol">ADS array symbol to read</param>
/// <returns>Object array of type T with values read from Symbol</returns>
public static T[] DeserializeArrayObject <T>(this ISymbol Symbol) where T : new()
{
// cast to IValueSymbol type
IValueSymbol symbol = (IValueSymbol)Symbol;
// instantiate new object array of symbol count size
var obj = new T[symbol.SubSymbols.Count];
// if primitive / non-struct type
if (symbol.IsPrimitiveType)
{
// cast to appropriate type and return
return((T[])symbol.ReadValue());
}
else
{
// iterate through each symbol array element
for (int i = 0; i < symbol.SubSymbols.Count; i++)
{
// call DeserializeObject on each element
obj[i] = DeserializeObject <T>(symbol.SubSymbols[i]);
}
}
// return generated array of type T
return(obj);
}
public void Dispose()
{
if (_client != null)
{
if (_eventSymbols.Count > 0)
{
// unregister events
foreach (string symbol in _eventSymbols)
{
IValueSymbol symb = (IValueSymbol)_symbolLoader.Symbols[symbol];
symb.ValueChanged -= Symbol_ValueChanged;
}
}
// dispose custom event container
_dynamicEvents.Dispose();
// disconnect client
if (_client.IsConnected)
{
_client.Disconnect();
}
_client.Dispose();
}
}
public static void WriteValues(this IValueSymbol symbol, IObservable <object> valueObservable, CancellationToken cancel)
{
Action <Exception> errorHandler = delegate(Exception ex) {
};
symbol.WriteValues(valueObservable, errorHandler, cancel);
}
public IValueSymbol WrapSymbol(IValueSymbol symbol)
{
if (symbol == null)
{
throw new ArgumentNullException("symbol");
}
return(this.create(symbol));
}
internal DynamicSymbol(IValueSymbol symbol)
{
if (symbol == null)
{
throw new ArgumentNullException("symbol");
}
this.symbol = symbol;
}
public static ExpandoObject GetStruct(this ISymbol Symbol)
{
// cast to IValueSymbol
IValueSymbol symbol = (IValueSymbol)Symbol;
// create dynamic expandable object to hold data
dynamic myobj = new ExpandoObject();
// primitive types
if (symbol.IsPrimitiveType)
{
((IDictionary <string, object>)myobj).Add(symbol.InstanceName, symbol.ReadValue());
//return myobj;
}
else
{
// array of structs
//***********NOT WORKING************
if (symbol.Category == DataTypeCategory.Array)
{
// declare sub element array for parallelization
// calling dict.Add() in parallel loop will result in
// out-of-order elements
var sub = new KeyValuePair <string, object> [symbol.SubSymbols.Count];
// loop through struct array and call recursively
for (int i = 0; i < symbol.SubSymbols.Count; i++)
{
sub[i] = new KeyValuePair <string, object>(symbol.SubSymbols[i].InstanceName, symbol.SubSymbols[i].GetStruct());
//((IDictionary<string, object>)myobj).Add(symbol.InstanceName, symbol.SubSymbols[i].GetStruct());
}
((IDictionary <string, object>)myobj).Add(symbol.InstanceName, sub);
//return myobj;
//// add loaded KVPs into dictionary
//foreach (KeyValuePair<string, object> pair in sub)
//{
// dict.Add(pair.Key, pair.Value);
//}
}
// struct
else if (symbol.Category == DataTypeCategory.Struct)
{
int i = 0;
foreach (IValueSymbol symb in symbol.SubSymbols)
{
if (symb.IsPrimitiveType)
{
((IDictionary <string, object>)myobj).Add(symb.InstanceName, symb.ReadValue());
}
else
{
((IDictionary <string, object>)myobj).Add(symb.InstanceName, symb.GetStruct());
}
i++;
}
}
}
return(myobj);
}
/// <summary>
/// Raises 'Method' action when SymbolPath value changes
/// </summary>
/// <param name="SymbolName">Path of Symbol to poll for value change</param>
/// <param name="Method">Action / method executed on value change</param>
public void SubscribeOnValueChange(string SymbolPath, Action <object> Method)
{
if (_dynamicEvents[SymbolPath] == null)
{
IValueSymbol symbol = (IValueSymbol)_symbolLoader.Symbols[SymbolPath];
symbol.ValueChanged += Symbol_ValueChanged;
_dynamicEvents.AddHandler(symbol.InstancePath, Method);
}
}
public Task Subscribe(IValueSymbol o)
{
_eventAggregator.PublishOnCurrentThreadAsync(new SymbolRegisterMessage()
{
RegisterType = RegisterType.Subscribe,
InstancePath = o.InstancePath
});
return(Task.CompletedTask);
}
/// <summary>
/// Reads ADS Symbol into Dictionary of key/value pairs.
/// Experimental. Very slow.
/// </summary>
/// <param name="Symbol">ADS symbol to read</param>
/// <returns>Dictionary of key/value pairs</returns>
public static Dictionary <string, object> ToDictionary(this ISymbol Symbol)
{
// cast to IValueSymbol
IValueSymbol symbol = (IValueSymbol)Symbol;
// create new dictionary
Dictionary <string, object> dict = new Dictionary <string, object>();
// primitive types
if (symbol.IsPrimitiveType)
{
dict.Add(symbol.InstanceName, symbol.ReadValue());
}
else
{
// array of structs
if (symbol.Category == DataTypeCategory.Array)
{
// declare sub element array for parallelization
// calling dict.Add() in parallel loop will result in
// out-of-order elements
var sub = new KeyValuePair <string, object> [symbol.SubSymbols.Count];
// loop through struct array and call recursively
for (int i = 0; i < symbol.SubSymbols.Count; i++)
{
sub[i] = new KeyValuePair <string, object>(symbol.SubSymbols[i].InstanceName, symbol.SubSymbols[i].ToDictionary());
}
// add loaded KVPs into dictionary
foreach (KeyValuePair <string, object> pair in sub)
{
dict.Add(pair.Key, pair.Value);
}
}
// struct
else if (symbol.Category == DataTypeCategory.Struct)
{
foreach (IValueSymbol symb in symbol.SubSymbols)
{
if (symb.IsPrimitiveType)
{
dict.Add(symb.InstanceName, symb.ReadValue());
}
else
{
dict.Add(symb.InstanceName, symb.ToDictionary());
}
}
}
}
return(dict);
}
public ISymbol CreateReferenceInstance(IPointerType type, ISymbol parent)
{
IValueSymbol symbol = (IValueSymbol)this.inner.CreateReferenceInstance(type, ((DynamicSymbol)parent).InnerSymbol);
ISymbol symbol2 = null;
if (symbol != null)
{
symbol2 = this.create(symbol);
}
return(symbol2);
}
public ISymbol CreateFieldInstance(IField field, ISymbol parent)
{
IValueSymbol symbol = (IValueSymbol)this.inner.CreateFieldInstance(field, parent);
ISymbol symbol2 = null;
if (symbol != null)
{
symbol2 = this.create(symbol);
}
return(symbol2);
}
public bool TryGetNotificationSettings(ISymbol symbol, out INotificationSettings settings)
{
IValueSymbol symbol2 = (IValueSymbol)symbol;
if (symbol2 != null)
{
settings = symbol2.NotificationSettings;
return(true);
}
settings = null;
return(false);
}
public ISymbol CreateOversamplingElement(ISymbol parent)
{
if (parent == null)
{
throw new ArgumentNullException("parent");
}
IValueSymbol symbol = (IValueSymbol)((ISymbolFactoryOversampled)this.inner).CreateOversamplingElement(parent);
ISymbol symbol2 = null;
if (symbol != null)
{
symbol2 = this.create(symbol);
}
return(symbol2);
}
/// <summary>
/// Raises OnSymbolValueChanged event when SymbolPath value changes
/// </summary>
/// <param name="SymbolName">Path of Symbol to poll for value change</param>
public void SubscribeOnValueChange(string SymbolPath)
{
if (_eventSymbols == null)
{
_eventSymbols = new List <string>();
}
if (!_eventSymbols.Contains(SymbolPath))
{
IValueSymbol symbol = (IValueSymbol)_symbolLoader.Symbols[SymbolPath];
symbol.ValueChanged += Symbol_ValueChanged;
_eventSymbols.Add(symbol.InstancePath);
}
}
public ISymbol CreateArrayElement(int[] currentIndex, ISymbol parent, IArrayType arrayType)
{
if (parent == null)
{
throw new ArgumentNullException("parent");
}
IValueSymbol symbol = (IValueSymbol)this.inner.CreateArrayElement(currentIndex, parent, arrayType);
ISymbol symbol2 = null;
if (symbol != null)
{
symbol2 = this.create(symbol);
}
return(symbol2);
}
public static void WriteValues(this IValueSymbol symbol, IObservable <object> valueObservable, Action <Exception> errorHandler, CancellationToken cancel)
{
Action <object> action = delegate(object o) {
try
{
symbol.WriteValue(o);
}
catch (Exception exception)
{
errorHandler(exception);
}
};
Action <Exception> action2 = ex => errorHandler(ex);
ObservableExtensions.Subscribe <object>(valueObservable, action, action2, delegate {
}, cancel);
}
private int readArraySize()
{
int num = 0;
IValueSymbol arraySizeSymbol = (IValueSymbol)this.ArraySizeSymbol;
if (arraySizeSymbol != null)
{
try
{
num = PrimitiveTypeConverter.Convert <int>(arraySizeSymbol.ReadValue());
}
catch (Exception)
{
}
}
return(num);
}
public static IDisposable WriteValues(this IValueSymbol symbol, IObservable <object> valueObservable, Action <Exception> errorHandler)
{
Action <object> action = delegate(object o) {
try
{
symbol.WriteValue(o);
}
catch (Exception exception)
{
errorHandler(exception);
}
};
Action <Exception> action2 = delegate(Exception ex) {
errorHandler(ex);
};
return(ObservableExtensions.Subscribe <object>(valueObservable, action, action2, delegate {
}));
}
public static IObservable <object> WhenValueChanged(this IValueSymbol symbol) =>
Observable.Select <EventPattern <ValueChangedArgs>, object>(Observable.FromEventPattern <EventHandler <ValueChangedArgs>, ValueChangedArgs>(delegate(EventHandler <ValueChangedArgs> h) {
symbol.ValueChanged += h;
}, delegate(EventHandler <ValueChangedArgs> h) {
symbol.ValueChanged -= h;
}), ev => ev.get_EventArgs().Value);
public static IObservable <object> PollValues(this IValueSymbol symbol, TimeSpan period)
{
long[] numArray1 = new long[] { -1L };
return(symbol.PollValues(Observable.Select <long, Unit>(Observable.StartWith <long>(Observable.Interval(period), numArray1), e => Unit.get_Default())));
}
public InsufficientAccessRights(IValueSymbol symbol, SymbolAccessRights requested) : base($"The requested rights '{requested}' for symbol '{symbol.InstanceName}' are not sufficient (Current rights: {symbol.AccessRights})!", symbol)
{
}
private IValueSymbol create(IValueSymbol symbol)
{
if (symbol == null)
{
throw new ArgumentNullException("symbol");
}
DataTypeCategory category = symbol.Category;
switch (category)
{
case DataTypeCategory.Alias:
{
IAliasInstance aliasInstance = symbol as IAliasInstance;
if (aliasInstance != null)
{
return(new DynamicAliasInstance(aliasInstance));
}
Module.Trace.TraceWarning($"'{symbol.InstancePath}' cannot be resolved to alias");
return(new DynamicSymbol(symbol));
}
case DataTypeCategory.Enum:
break;
case DataTypeCategory.Array:
if (symbol is IArrayInstance)
{
return(!(symbol is IOversamplingArrayInstance) ? new DynamicArrayInstance((IArrayInstance)symbol) : new DynamicOversamplingArrayInstance((IOversamplingArrayInstance)symbol));
}
Module.Trace.TraceWarning($"'{symbol.InstancePath}' cannot be resolved to array");
return(new DynamicSymbol(symbol));
case DataTypeCategory.Struct:
{
IStructInstance instance3 = symbol as IStructInstance;
if (instance3 != null)
{
return(!instance3.HasRpcMethods ? new DynamicStructInstance((IStructInstance)symbol) : new DynamicRpcStructInstance((IRpcStructInstance)symbol));
}
Module.Trace.TraceWarning($"'{symbol.InstancePath}' cannot be resolved to struct");
return(new DynamicSymbol(symbol));
}
default:
switch (category)
{
case DataTypeCategory.Pointer:
{
IPointerInstance pointerInstance = symbol as IPointerInstance;
if (pointerInstance != null)
{
return(new DynamicPointerInstance(pointerInstance));
}
Module.Trace.TraceWarning($"'{symbol.InstancePath}' cannot be resolved to pointer");
return(new DynamicSymbol(symbol));
}
case DataTypeCategory.Union:
{
IUnionInstance unionInstance = symbol as IUnionInstance;
if (unionInstance != null)
{
return(new DynamicUnionInstance(unionInstance));
}
Module.Trace.TraceWarning($"'{symbol.InstancePath}' cannot be resolved to union");
return(new DynamicSymbol(symbol));
}
case DataTypeCategory.Reference:
{
IReferenceInstance refInstance = symbol as IReferenceInstance;
if (refInstance != null)
{
return(new DynamicReferenceInstance(refInstance));
}
Module.Trace.TraceWarning($"'{symbol.InstancePath}' cannot be resolved to reference");
return(new DynamicSymbol(symbol));
}
default:
break;
}
break;
}
return(new DynamicSymbol(symbol));
}
public static IObservable <ValueChangedArgs> PollValuesAnnotated(this IValueSymbol symbol, IObservable <Unit> trigger) => Observable.Select <object, ValueChangedArgs>(symbol.PollValues(trigger), o => new ValueChangedArgs(symbol, o, DateTime.UtcNow));
public static IObservable <ValueChangedArgs> PollValuesAnnotated(this IValueSymbol symbol, TimeSpan period) => Observable.Select <object, ValueChangedArgs>(symbol.PollValues(period), o => new ValueChangedArgs(symbol, o, DateTime.UtcNow));
public static IObservable <ValueChangedArgs> WhenValueChangedAnnotated(this IAdsConnection connection, IValueSymbol symbol) =>
Observable.Select <EventPattern <ValueChangedArgs>, ValueChangedArgs>(Observable.FromEventPattern <EventHandler <ValueChangedArgs>, ValueChangedArgs>(delegate(EventHandler <ValueChangedArgs> h) {
symbol.ValueChanged += h;
}, delegate(EventHandler <ValueChangedArgs> h) {
symbol.ValueChanged -= h;
}), ev => ev.get_EventArgs());
public ISymbol CreateInstance(ISymbolInfo entry, ISymbol parent)
{
IValueSymbol symbol = (IValueSymbol)this.inner.CreateInstance(entry, parent);
return(this.WrapSymbol(symbol));
}
public static IObservable <object> PollValues(this IValueSymbol symbol, IObservable <Unit> trigger)
{
Func <Unit, object> func = o => symbol.ReadValue();
return(Observable.Select <Unit, object>(trigger, func));
}
/// <summary>
/// Writes to ADS symbol from custom object type.
/// </summary>
/// <param name="Symbol">ADS Symbol to write</param>
/// <param name="Data">User defined object (class or struct with matching properties) to write to Symbol</param>
public static void SerializeObject(this ISymbol Symbol, object Object)
{
// cast to IValueSymbol type (for read/write)
IValueSymbol symbol = (IValueSymbol)Symbol;
// if primitive type
if (symbol.IsPrimitiveType)
{
// write object to symbol value
symbol.WriteValue(Object);
}
else
{
// symbol is array of non-primitive (struct array)
if (symbol.Category == DataTypeCategory.Array)
{
// validate Object parameter is array
if (Object.GetType().IsArray)
{
// cast Object to array var for indexing
var arr = (Array)Object;
// loop through elements (with upper bounds check)
for (int i = 0; i < Math.Max(symbol.SubSymbols.Count, arr.Length); i++)
{
// get Object element, call recursively
if (arr.GetValue(i) != null)
{
SerializeObject(symbol.SubSymbols[i], arr.GetValue(i));
}
}
}
else
{
// array type mismatch exception
throw new Exception("Type mismatch: Object parameter is not array type.");
}
}
else
{
foreach (ISymbol symb in symbol.SubSymbols)
{
// get IValueSymbol
IValueSymbol vSymb = (IValueSymbol)symb;
// check if Object parameter contains matching property
var property = Object.GetType().GetProperty(vSymb.InstanceName);
if (property != null)
{
// if symbol is primitive
if (vSymb.IsPrimitiveType)
{
// write object property value to symbol
vSymb.WriteValue(property.GetValue(Object));
}
else
{
// if sub symbol is array type
if (vSymb.Category == DataTypeCategory.Array)
{
// cast property to array var for indexing
var arr = (Array)property.GetValue(Object);
// loop through elements (with upper bounds check)
for (int i = 0; i < Math.Max(vSymb.SubSymbols.Count, arr.Length); i++)
{
// if property array index is initialized, call recursively
if (arr.GetValue(i) != null)
{
SerializeObject(vSymb.SubSymbols[i], arr.GetValue(i));
}
}
}
else
{
// call recursively on struct
SerializeObject(vSymb, property.GetValue(Object));
}
}
}
}
}
}
}
