/// <summary>
/// Show settings of selected media.
/// </summary>
private void MediaCB_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
MediaFrame.Controls.Clear();
GXClient cl = new GXClient();
SelectedMedia = cl.SelectMedia(MediaCB.Text);
if (SelectedMedia == null)
{
throw new Exception(MediaCB.Text + " media not found.");
}
if (!string.IsNullOrEmpty(Gurux.DeviceSuite.Properties.Settings.Default.CommandPrompSettings))
{
List<string> arr = new List<string>(Gurux.DeviceSuite.Properties.Settings.Default.CommandPrompSettings.Split(new char[]{';'}));
if (arr.Count > 1)
{
arr.RemoveAt(0);
SelectedMedia.Settings = string.Join(";", arr.ToArray());
}
}
if (SelectedMedia is GXSerial)
{
(SelectedMedia as GXSerial).AvailablePorts = DataCollector.SerialPorts;
}
if (SelectedMedia is GXAmiGateway)
{
GXAmiGateway gw = SelectedMedia as GXAmiGateway;
gw.Host = Gurux.DeviceSuite.Properties.Settings.Default.AmiHostName;
gw.UserName = Gurux.DeviceSuite.Properties.Settings.Default.AmiUserName;
gw.Password = Gurux.DeviceSuite.Properties.Settings.Default.AmiPassword;
}
PropertiesForm = SelectedMedia.PropertiesForm;
((IGXPropertyPage)PropertiesForm).Initialize();
while (PropertiesForm.Controls.Count != 0)
{
Control ctr = PropertiesForm.Controls[0];
if (ctr is Panel)
{
if (!ctr.Enabled)
{
PropertiesForm.Controls.RemoveAt(0);
continue;
}
}
MediaFrame.Controls.Add(ctr);
}
}
catch (Exception ex)
{
GXCommon.ShowError(this, ex);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="collectors"></param>
/// <param name="medias"></param>
/// <param name="media"></param>
public RedundantForm(GXClient client, GXAmiDataCollector[] collectors, GXAmiMediaType[] medias, GXAmiDeviceMedia media)
{
InitializeComponent();
Client = client;
Collectors = collectors;
Medias = medias;
SelectedMedia = media;
UpdateCollectors();
if (media.DataCollectorId == null)
{
UpdateMedias();
}
if (!string.IsNullOrEmpty(SelectedMedia.Settings))
{
Media.Settings = SelectedMedia.Settings;
((IGXPropertyPage)PropertiesForm).Initialize();
}
}
/// <summary>
/// Create a copy of the GXPacket.
/// </summary>
public void Copy(GXPacket source)
{
Clear();
lock (source.SyncRoot)
{
AppendData(source.ExtractData(typeof(byte[]), 0, -1));
this.Bop = source.Bop;
this.Eop = source.Eop;
this.ChecksumSettings.Copy(source.ChecksumSettings);
this.Sender = source.Sender;
}
}
/// <summary>
/// Remove client from the server.
/// </summary>
/// <param name="server"></param>
/// <param name="client"></param>
public static void Release(GXServer server, GXClient client)
{
lock (m_syncRoot)
{
try
{
if (client.Tracing)
{
server.Media.OnTrace -= new TraceEventHandler(client.media_OnTrace);
client.Tracing = false;
}
}
catch (Exception ex)
{
//Ignore if fails.
System.Diagnostics.Debug.WriteLine(ex.Message);
}
int cnt = 0;
lock (server.Clients.SyncRoot)
{
cnt = server.Clients.Count;
}
if (cnt == 1)
{
server.m_Sender.Closing.Set();
server.m_Receiver.Closing.Set();
server.m_SendThread.Join();
server.m_ReceiverThread.Join();
if (server.Media != null)
{
if (server.Media != null)
{
server.Media.Close();
}
}
server.Clients.Remove(client);
m_instances.Remove(server.m_Name);
}
else
{
server.Clients.Remove(client);
}
}
}
/// <summary>
/// GXServer class factory.
/// </summary>
public static GXServer Instance(Gurux.Common.IGXMedia media, GXClient client)
{
lock (m_syncRoot)
{
if (m_instances == null)
{
m_instances = new Dictionary<string, GXServer>();
Handlers = new Dictionary<IGXEventHandler, object>();
}
string name = media.Name;
if (string.IsNullOrEmpty(name))
{
name = media.MediaType;
}
GXServer server;
if (m_instances.ContainsKey(name))
{
server = m_instances[name];
if (server.m_bParseReceivedPacket != client.ParseReceivedPacket)
{
throw new Exception(Resources.ServerFailedToAcceptNewClientParseReceivedPacketValueIsInvalid);
}
if (!object.Equals(server.m_ReplyPacket.Eop, client.Eop))
{
throw new Exception(Resources.ServerFailedToAcceptNewClientEopValueIsInvalid);
}
if (!object.Equals(server.m_ReplyPacket.Bop, client.Bop))
{
throw new Exception(Resources.ServerFailedToAcceptNewClientBopValueIsInvalid);
}
if (server.m_ReplyPacket.ByteOrder != client.ByteOrder)
{
throw new Exception(Resources.ServerFailedToAcceptNewClientByteOrdersAreNotSame);
}
if (server.m_ReplyPacket.MinimumSize != client.MinimumSize)
{
throw new Exception(Resources.ServerFailedToAcceptNewClientMinimumSizeValueIsInvalid);
}
if (!server.m_ReplyPacket.ChecksumSettings.Equals(client.ChecksumSettings))
{
throw new Exception(Resources.ServerFailedToAcceptNewClientChecksumSettingsAreNotSame);
}
lock (server.Clients.SyncRoot)
{
server.Clients.Add(client);
}
return server;
}
server = new GXServer(name);
server.m_ReplyPacket = client.CreatePacket();
lock (server.Clients.SyncRoot)
{
server.Clients.Add(client);
}
server.m_bParseReceivedPacket = client.ParseReceivedPacket;
media.OnClientDisconnected += new Gurux.Common.ClientDisconnectedEventHandler(server.OnClientDisconnected);
media.OnClientConnected += new Gurux.Common.ClientConnectedEventHandler(server.OnClientConnected);
media.OnError += new Gurux.Common.ErrorEventHandler(server.OnError);
media.OnMediaStateChange += new Gurux.Common.MediaStateChangeEventHandler(server.OnMediaStateChange);
media.OnReceived += new Gurux.Common.ReceivedEventHandler(server.OnReceived);
server.m_Media = media;
m_instances[name] = server;
server.m_Sender = new GXServerSender(server);
server.m_Receiver = new GXServerReceiver(server);
server.m_SendThread = new Thread(new ThreadStart(server.m_Sender.Run));
server.m_SendThread.IsBackground = true;
server.m_SendThread.Start();
server.m_ReceiverThread = new Thread(new ThreadStart(server.m_Receiver.Run));
server.m_ReceiverThread.IsBackground = true;
server.m_ReceiverThread.Start();
return server;
}
}
/// <summary>
/// Copy client and media settings from the source.
/// </summary>
/// <param name="source">Source where settings are copied.</param>
public void Copy(GXClient source)
{
lock (this.SyncRoot)
{
lock (source.SyncRoot)
{
CloseServer();
this.Bop = source.Bop;
this.ByteOrder = source.ByteOrder;
this.ChecksumSettings.Copy(source.ChecksumSettings);
this.Eop = source.Eop;
this.Eop = source.PacketParser;
this.ParseReceivedPacket = source.ParseReceivedPacket;
this.ResendCount = source.ResendCount;
this.WaitTime = source.WaitTime;
//Copy media settings.
if (source.Media != null)
{
IGXMedia media = this.SelectMedia(source.Media.MediaType) as IGXMedia;
media.Settings = source.Media.Settings;
this.AssignMedia(media);
}
}
}
}
/// <summary>
/// Creates a copy of the client.
/// </summary>
/// <returns>Cloned client.</returns>
public GXClient Clone()
{
GXClient client = new GXClient();
client.Copy(this);
return client;
}
private void MediaCB_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
MediaFrame.Controls.Clear();
if (Target.Media == null || Target.Media.MediaType != MediaCB.Text)
{
GXClient cl = new GXClient();
Target.Media = cl.SelectMedia(MediaCB.Text);
if (Target.Media == null)
{
throw new Exception(MediaCB.Text + " media not found.");
}
}
if (Target.GXClient != null && Target.GXClient.PacketParser != null)
{
Target.GXClient.PacketParser.InitializeMedia(Target.GXClient, Target.Media);
}
if (!string.IsNullOrEmpty(Target.MediaSettings))
{
Target.Media.Settings = Target.MediaSettings;
}
if (Target.Media is GXSerial)
{
(Target.Media as GXSerial).AvailablePorts = (DataCollectorCB.SelectedItem as GXAmiDataCollector).SerialPorts;
}
else if (Target.Media is GXTerminal)
{
(Target.Media as GXTerminal).AvailablePorts = (DataCollectorCB.SelectedItem as GXAmiDataCollector).SerialPorts;
}
PropertiesForm = Target.Media.PropertiesForm;
((IGXPropertyPage)PropertiesForm).Initialize();
while (PropertiesForm.Controls.Count != 0)
{
Control ctr = PropertiesForm.Controls[0];
if (ctr is Panel)
{
if (!ctr.Enabled)
{
PropertiesForm.Controls.RemoveAt(0);
continue;
}
}
MediaFrame.Controls.Add(ctr);
}
}
catch (Exception ex)
{
GXCommon.ShowError(this, ex);
}
}
private void SendPacket(GXClient client, int delay, GXPacket packet)
{
if (ReserveMedia)
{
lock (client.SyncCommunication)
{
Statistics.PacketSendTime = DateTime.Now;
if (delay > 0 && Statistics.PacketReceiveTime != DateTime.MinValue)
{
delay -= (int)(DateTime.Now - Statistics.PacketReceiveTime).TotalMilliseconds;
if (delay > 0)
{
if (Tracing && m_OnTrace != null)
{
m_OnTrace(this, new TraceEventArgs(TraceTypes.Info, string.Format(Resources.Wait0MsBeforeNextPacketIsSend, delay), null));
}
System.Threading.Thread.Sleep(delay);
}
}
client.Send(packet, true);
}
}
else
{
Statistics.PacketSendTime = DateTime.Now;
if (delay > 0 && Statistics.PacketReceiveTime != DateTime.MinValue)
{
delay -= (int)(DateTime.Now - Statistics.PacketReceiveTime).TotalMilliseconds;
if (delay > 0)
{
if (Tracing && m_OnTrace != null)
{
m_OnTrace(this, new TraceEventArgs(TraceTypes.Info, string.Format(Resources.Wait0MsBeforeNextPacketIsSend, delay), null));
}
System.Threading.Thread.Sleep(delay);
}
}
client.Send(packet, true);
}
if (!IsCancelled)
{
Statistics.PacketReceiveTime = DateTime.Now;
}
}
/// <summary>
/// Execute transaction.
/// </summary>
/// <param name="sender"></param>
/// <param name="client"></param>
/// <param name="att"></param>
/// <param name="initialTransaction"></param>
/// <param name="read"></param>
/// <returns>Returs False if if there are more items to read.</returns>
internal bool Execute(object sender, object parameters, GXClient client, GXCommunicationMessageAttribute att, bool initialTransaction, bool read)
{
//If transaction is cancelled.
if (IsCancelled)
{
return false;
}
if (Keepalive.TransactionResets)
{
if (client.Trace >= System.Diagnostics.TraceLevel.Info)
{
Gurux.Common.GXCommon.TraceWriteLine(DateTime.Now.ToShortTimeString() + " Resets keepalive.");
}
Keepalive.Reset();
}
if (att != null)
{
if (!initialTransaction && att.EnableParentRead)
{
return true;
}
int delay = 0;
GXProperty prop = null;
GXCategory cat = null;
GXTable table = null;
GXDevice device = null;
if (sender is GXProperty)
{
prop = sender as GXProperty;
prop.NotifyPropertyChange(read ? PropertyStates.ReadStart : PropertyStates.WriteStart);
delay = prop.TransactionDelay;
//If device transaction delay is used.
if (delay == -1)
{
delay = prop.Device.TransactionDelay;
}
}
else if (sender is GXCategory)
{
cat = sender as GXCategory;
}
else if (sender is GXTable)
{
table = sender as GXTable;
delay = table.TransactionDelay;
//If device transaction delay is used.
if (delay == -1)
{
delay = table.Device.TransactionDelay;
}
}
else if (sender is GXDevice)
{
device = sender as GXDevice;
delay = device.TransactionDelay;
}
DateTime start = DateTime.Now;
List<GXPacket> packets = new List<GXPacket>();
try
{
GXPacket packet = client.CreatePacket();
packets.Add(packet);
if (!string.IsNullOrEmpty(att.RequestMessageHandler))
{
if (att is GXEventMessage)
{
object[] tmp = (object[])parameters;
this.PacketHandler.ExecuteNotifyCommand(sender, att.RequestMessageHandler, packet, (byte[])tmp[0], (string)(tmp[1]));
}
else
{
this.PacketHandler.ExecuteSendCommand(sender, att.RequestMessageHandler, packet);
}
//If there is no data to send.
if (packet.GetSize(PacketParts.Data) == 0)
{
return true;
}
//If we are not expected reply.
if (string.IsNullOrEmpty(att.ReplyMessageHandler))
{
packet.ResendCount = -1;
}
SendPacket(client, delay, packet);
//If transaction is cancelled.
if (IsCancelled)
{
return false;
}
if ((packet.Status & (PacketStates.Timeout | PacketStates.SendFailed)) != 0)
{
//If connection is closed.
if (!client.MediaIsOpen)
{
return false;
}
if ((packet.Status & PacketStates.Timeout) != 0)
{
throw new Exception(Resources.TimeoutOccurred);
}
else
{
throw new Exception(Resources.SendFailed);
}
}
if (string.IsNullOrEmpty(att.IsAllSentMessageHandler))
{
if (!string.IsNullOrEmpty(att.ReplyMessageHandler))
{
this.PacketHandler.ExecuteParseCommand(sender, att.ReplyMessageHandler, packets.ToArray());
}
}
else
{
while (!Closing && !this.PacketHandler.IsTransactionComplete(sender, att.IsAllSentMessageHandler, packet))
{
if (Keepalive.TransactionResets)
{
if (client.Trace >= System.Diagnostics.TraceLevel.Info)
{
Gurux.Common.GXCommon.TraceWriteLine(DateTime.Now.ToShortTimeString() + " Resets keepalive.");
}
Keepalive.Reset();
}
packet = client.CreatePacket();
packets.Add(packet);
this.PacketHandler.ExecuteSendCommand(sender, att.AcknowledgeMessageHandler, packet);
//If there is no data to send.
if (packet.GetSize(PacketParts.Data) == 0)
{
throw new Exception(Resources.InvalidAcknowledgeMessage + att.AcknowledgeMessageHandler + ".");
}
SendPacket(client, delay, packet);
if ((packet.Status & (PacketStates.Timeout | PacketStates.SendFailed)) != 0)
{
//If connection is closed.
if (!client.MediaIsOpen)
{
return false;
}
if ((packet.Status & PacketStates.Timeout) != 0)
{
throw new Exception(Resources.TimeoutOccurred);
}
else
{
throw new Exception(Resources.SendFailed);
}
}
}
this.PacketHandler.ExecuteParseCommand(sender, att.ReplyMessageHandler, packets.ToArray());
}
if (prop != null)
{
if (read)
{
++prop.Statistics.ReadCount;
}
else
{
++prop.Statistics.WriteCount;
}
prop.Statistics.UpdateExecutionTime(DateTime.Now - start);
prop.NotifyPropertyChange(read ? PropertyStates.ReadEnd : PropertyStates.WriteEnd);
}
else if (cat != null)
{
if (read)
{
++cat.Statistics.ReadCount;
}
else
{
++cat.Statistics.WriteCount;
}
cat.Statistics.UpdateExecutionTime(DateTime.Now - start);
}
else if (table != null)
{
if (read)
{
++table.Statistics.ReadCount;
}
else
{
++table.Statistics.WriteCount;
}
table.Statistics.UpdateExecutionTime(DateTime.Now - start);
}
else if (device != null && !(att is GXInitialActionMessage))
{
if (read)
{
++device.Statistics.ReadCount;
}
else
{
++device.Statistics.WriteCount;
}
device.Statistics.UpdateExecutionTime(DateTime.Now - start);
}
}
}
catch (Exception Ex)
{
if (prop != null)
{
if (read)
{
++prop.Statistics.ReadFailCount;
}
else
{
++prop.Statistics.WriteFailCount;
}
}
else if (cat != null)
{
if (read)
{
++cat.Statistics.ReadFailCount;
}
else
{
++cat.Statistics.WriteFailCount;
}
}
else if (table != null)
{
if (read)
{
++table.Statistics.ReadFailCount;
}
else
{
++table.Statistics.WriteFailCount;
}
}
else if (device != null && !(att is GXInitialActionMessage))
{
if (read)
{
++device.Statistics.ReadFailCount;
}
else
{
++device.Statistics.WriteFailCount;
}
}
if (prop != null)
{
throw new Exception(string.Format(Resources.ReadFailed, prop.Name, Ex.Message), Ex);
}
else if (cat != null)
{
throw new Exception(string.Format(Resources.ReadFailed, cat.Name, Ex.Message), Ex);
}
else if (table != null)
{
throw new Exception(string.Format(Resources.ReadFailed, table.Name, Ex.Message), Ex);
}
NotifyTransactionProgress(this, new GXTransactionProgressEventArgs(sender, 1, 1, DeviceStates.ReadEnd));
throw Ex;
}
finally
{
client.ReleasePacket(packets);
}
}
else //If selected item do not have transaction messages.
{
if ((Status & DeviceStates.Disconnecting) != 0)
{
return false;
}
//If we have read all items...
if (TransactionObject == sender)
{
return false;
}
if (TransactionObject == null)
{
TransactionObject = sender;
}
if (sender is GXDevice)
{
//If we have read all items...
if (TransactionObject is GXTable || TransactionObject is GXTable || TransactionObject is GXProperty)
{
return false;
}
bool bFound = false;
if (TransactionObject == sender)
{
TransactionPos = 1;
TransactionCount = this.Tables.Count;
foreach (GXCategory cat in this.Categories)
{
if (Closing)
{
break;
}
if (GXDeviceList.CanExecute(cat.DisabledActions, Status, read))
{
TransactionCount += cat.Properties.Count + 1;
}
}
NotifyTransactionProgress(this, new GXTransactionProgressEventArgs(sender, 0, TransactionCount, read ? DeviceStates.ReadStart : DeviceStates.WriteStart));
}
try
{
foreach (GXCategory it in this.Categories)
{
if (!Closing && GXDeviceList.CanExecute(it.DisabledActions, Status, read))
{
List<KeyValuePair<GXCommunicationMessageAttribute, object>> attributes = new List<KeyValuePair<GXCommunicationMessageAttribute, object>>();
GetCommunicationMessageAttributes(it, read ? typeof(GXReadMessage) : typeof(GXWriteMessage), attributes, false);
if (attributes.Count == 0)
{
if (!Execute(it, parameters, client, null, initialTransaction, read))
{
break;
}
}
else
{
foreach (var it2 in attributes)
{
TransactionObject = null;
if (!Execute(it2.Value, parameters, this.GXClient, it2.Key, true, read))
{
break;
}
}
}
}
}
foreach (GXTable it in this.Tables)
{
if (!Closing && GXDeviceList.CanExecute(it.DisabledActions, Status, read))
{
List<KeyValuePair<GXCommunicationMessageAttribute, object>> attributes = new List<KeyValuePair<GXCommunicationMessageAttribute, object>>();
GetCommunicationMessageAttributes(it, read ? typeof(GXReadMessage) : typeof(GXWriteMessage), attributes, false);
if (attributes.Count == 0)
{
if (!Execute(it, parameters, client, null, initialTransaction, read))
{
break;
}
}
else
{
foreach (var it2 in attributes)
{
TransactionObject = null;
if (!Execute(it2.Value, parameters, this.GXClient, it2.Key, true, read))
{
break;
}
}
}
}
}
if (read)
{
++this.Statistics.ReadCount;
}
else
{
++this.Statistics.WriteCount;
}
}
catch (Exception Ex)
{
if (read)
{
++this.Statistics.ReadFailCount;
}
else
{
++this.Statistics.WriteFailCount;
}
throw Ex;
}
finally
{
if (TransactionObject == sender)
{
NotifyTransactionProgress(this, new GXTransactionProgressEventArgs(sender, TransactionCount, TransactionCount, read ? DeviceStates.ReadEnd : DeviceStates.WriteEnd));
TransactionCount = TransactionPos = 1;
}
}
return bFound;
}
if (sender is GXProperty)
{
if (TransactionObject is GXProperty)
{
try
{
NotifyTransactionProgress(this, new GXTransactionProgressEventArgs(sender, 0, 1, read ? DeviceStates.ReadStart : DeviceStates.ReadStart));
object it = (sender as GXProperty).Parent.Parent;
List<KeyValuePair<GXCommunicationMessageAttribute, object>> attributes = new List<KeyValuePair<GXCommunicationMessageAttribute, object>>();
GetCommunicationMessageAttributes(it, read ? typeof(GXReadMessage) : typeof(GXWriteMessage), attributes, false);
foreach (var cAtt in attributes)
{
if (Closing)
{
break;
}
if (!Execute(it, parameters, client, cAtt.Key, initialTransaction, read))
{
return false;
}
}
return true;
}
finally
{
NotifyTransactionProgress(this, new GXTransactionProgressEventArgs(sender, 1, 1, read ? DeviceStates.ReadEnd : DeviceStates.WriteEnd));
}
}
return false;
}
if (sender is GXCategory)
{
if (TransactionObject is GXProperty)
{
GXDevice device = (sender as GXCategory).Device;
List<KeyValuePair<GXCommunicationMessageAttribute, object>> attributes = new List<KeyValuePair<GXCommunicationMessageAttribute, object>>();
GetCommunicationMessageAttributes(device, read ? typeof(GXReadMessage) : typeof(GXWriteMessage), attributes, false);
foreach (var cAtt in attributes)
{
if (Closing)
{
break;
}
if (!Execute(device, parameters, client, cAtt.Key, initialTransaction, read))
{
return false;
}
}
return true;
}
bool bFound = false;
if (TransactionObject == sender)
{
TransactionPos = 1;
TransactionCount = (sender as GXCategory).Properties.Count + 1;
NotifyTransactionProgress(this, new GXTransactionProgressEventArgs(sender, 0, TransactionCount, read ? DeviceStates.ReadStart : DeviceStates.ReadStart));
}
try
{
bFound = true;
foreach (GXProperty it in (sender as GXCategory).Properties)
{
if (!Closing && GXDeviceList.CanExecute(it.DisabledActions, Status, read))
{
NotifyTransactionProgress(this, new GXTransactionProgressEventArgs(it, TransactionPos++, TransactionCount, read ? DeviceStates.ReadStart : DeviceStates.ReadStart));
List<KeyValuePair<GXCommunicationMessageAttribute, object>> attributes = new List<KeyValuePair<GXCommunicationMessageAttribute, object>>();
GetCommunicationMessageAttributes(it, read ? typeof(GXReadMessage) : typeof(GXWriteMessage), attributes, false);
foreach (var cAtt in attributes)
{
if (!Execute(it, parameters, client, cAtt.Key, initialTransaction, read))
{
break;
}
}
NotifyTransactionProgress(this, new GXTransactionProgressEventArgs(it, TransactionPos, TransactionCount, read ? DeviceStates.ReadEnd : DeviceStates.WriteEnd));
}
}
if (read)
{
++(sender as GXCategory).Statistics.ReadCount;
}
else
{
++(sender as GXCategory).Statistics.WriteCount;
}
}
catch (Exception Ex)
{
if (read)
{
++(sender as GXCategory).Statistics.ReadFailCount;
}
else
{
++(sender as GXCategory).Statistics.WriteFailCount;
}
throw Ex;
}
finally
{
if (TransactionObject == sender)
{
NotifyTransactionProgress(this, new GXTransactionProgressEventArgs(sender, TransactionCount, TransactionCount, read ? DeviceStates.ReadEnd : DeviceStates.WriteEnd));
TransactionCount = TransactionPos = 1;
}
}
return bFound;
}
if (sender is GXTable)
{
try
{
GXDevice device = ((GXTable)sender).Device;
List<KeyValuePair<GXCommunicationMessageAttribute, object>> attributes = new List<KeyValuePair<GXCommunicationMessageAttribute, object>>();
GetCommunicationMessageAttributes(device, read ? typeof(GXReadMessage) : typeof(GXWriteMessage), attributes, false);
foreach (var cAtt in attributes)
{
if (Closing)
{
break;
}
if (!Execute(device, parameters, client, cAtt.Key, initialTransaction, read))
{
return false;
}
}
if (read)
{
++((GXTable)sender).Statistics.ReadCount;
}
else
{
++((GXTable)sender).Statistics.WriteCount;
}
return true;
}
catch (Exception Ex)
{
if (read)
{
++((GXTable)sender).Statistics.ReadFailCount;
}
else
{
++((GXTable)sender).Statistics.WriteFailCount;
}
throw Ex;
}
}
}
return true;
}