private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.OutageTopologyModel)
{
this.outageTopologyModel = await ReliableDictionaryAccess <string, OutageTopologyModel> .Create(stateManager, ReliableDictionaryNames.OutageTopologyModel);
this.isOutageTopologyModelInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.OutageTopologyModel}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.CommandedElements)
{
this.commandedElements = await ReliableDictionaryAccess <long, CommandedElement> .Create(stateManager, ReliableDictionaryNames.CommandedElements);
this.isCommandedElementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.CommandedElements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.SimulatedOutages)
{
simulatedOutages = await ReliableDictionaryAccess <long, SimulatedOutage> .Create(stateManager, ReliableDictionaryNames.SimulatedOutages);
this.isSimulatedOutagesInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.SimulatedOutages}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.MonitoredIsolationPoints)
{
monitoredIsolationPoints = await ReliableDictionaryAccess <long, MonitoredIsolationPoint> .Create(stateManager, ReliableDictionaryNames.MonitoredIsolationPoints);
this.isMonitoredIsolationPointsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.MonitoredIsolationPoints}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.ActiveTransactions)
{
activeTransactions = await ReliableDictionaryAccess <string, HashSet <string> > .Create(stateManager, ReliableDictionaryNames.ActiveTransactions);
isActiveTransactionsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.ActiveTransactions}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.TransactionEnlistmentLedger)
{
transactionEnlistmentLedger = await ReliableDictionaryAccess <string, HashSet <string> > .Create(stateManager, ReliableDictionaryNames.TransactionEnlistmentLedger);
isTransactionEnlistmentLedgerInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.TransactionEnlistmentLedger}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.MonitoredHeadBreakerMeasurements)
{
this.monitoredHeadBreakerMeasurements = await ReliableDictionaryAccess <long, DiscreteModbusData> .Create(stateManager, ReliableDictionaryNames.MonitoredHeadBreakerMeasurements);
this.isMonitoredHeadBreakerMeasurementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.MonitoredHeadBreakerMeasurements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.StartedIsolationAlgorithms)
{
this.startedIsolationAlgorithms = await ReliableDictionaryAccess <long, IsolationAlgorithm> .Create(stateManager, ReliableDictionaryNames.StartedIsolationAlgorithms);
this.isStartedIsolationAlgorithmsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.StartedIsolationAlgorithms}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.StartedIsolationAlgorithms)
{
this.startedIsolationAlgorithms = await ReliableDictionaryAccess <long, IsolationAlgorithm> .Create(stateManager, ReliableDictionaryNames.StartedIsolationAlgorithms);
this.isStartedIsolationAlgorithmsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.StartedIsolationAlgorithms}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.MonitoredHeadBreakerMeasurements)
{
this.monitoredHeadBreakerMeasurements = await ReliableDictionaryAccess <long, DiscreteModbusData> .Create(stateManager, ReliableDictionaryNames.MonitoredHeadBreakerMeasurements);
this.isMonitoredHeadBreakerMeasurementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.MonitoredHeadBreakerMeasurements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.OutageTopologyModel)
{
this.outageTopologyModel = await ReliableDictionaryAccess <string, OutageTopologyModel> .Create(stateManager, ReliableDictionaryNames.OutageTopologyModel);
this.isOutageTopologyModelInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.OutageTopologyModel}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.OptimumIsolationPoints)
{
this.optimumIsolationPoints = await ReliableDictionaryAccess <long, long> .Create(stateManager, ReliableDictionaryNames.OptimumIsolationPoints);
this.isOptimumIsolationPointsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.OptimumIsolationPoints}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.CommandedElements)
{
this.commandedElements = await ReliableDictionaryAccess <long, CommandedElement> .Create(stateManager, ReliableDictionaryNames.CommandedElements);
this.isCommandedElementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.CommandedElements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.ActiveOutages)
{
activeOutages = await ReliableDictionaryAccess <long, ActiveOutageMessage> .Create(this.stateManager, ReliableDictionaryNames.ActiveOutages);
this.isActiveOutagesInitialized = true;
}
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.GidToPointItemMap)
{
//_ = GidToPointItemMap;
gidToPointItemMap = await ReliableDictionaryAccess <long, IScadaModelPointItem> .Create(stateManager, ReliableDictionaryNames.GidToPointItemMap);
isGidToPointItemMapInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.GidToPointItemMap}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.AddressToGidMap)
{
//_ = AddressToGidMap;
addressToGidMap = await ReliableDictionaryAccess <short, Dictionary <ushort, long> > .Create(stateManager, ReliableDictionaryNames.AddressToGidMap);
isAddressToGidMapInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.AddressToGidMap}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.CommandDescriptionCache)
{
//_ = CommandDescriptionCache;
commandDescriptionCache = await ReliableDictionaryAccess <long, CommandDescription> .Create(stateManager, ReliableDictionaryNames.CommandDescriptionCache);
isCommandDescriptionCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.CommandDescriptionCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.InfoCache)
{
//_ = InfoCache;
infoCache = await ReliableDictionaryAccess <string, bool> .Create(stateManager, ReliableDictionaryNames.InfoCache);
isInfoCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.InfoCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.CallsDictionary)
{
calls = await ReliableDictionaryAccess <long, long> .Create(this.stateManager, ReliableDictionaryNames.CallsDictionary);
this.isCallsDictionaryInitialized = true;
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.RegisteredSubscribersCache)
{
//_ = SubscriberCache;
registeredSubscribersCache = await ReliableDictionaryAccess <short, HashSet <string> > .Create(stateManager, ReliableDictionaryNames.RegisteredSubscribersCache);
isSubscriberCacheInitialized = true;
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.MonitoredHeadBreakerMeasurements)
{
this.monitoredHeadBreakerMeasurements = await ReliableDictionaryAccess <long, DiscreteModbusData> .Create(stateManager, ReliableDictionaryNames.MonitoredHeadBreakerMeasurements);
this.isMonitoredHeadBreakerMeasurementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.MonitoredHeadBreakerMeasurements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.OutageTopologyModel)
{
this.outageTopologyModel = await ReliableDictionaryAccess <string, OutageTopologyModel> .Create(stateManager, ReliableDictionaryNames.OutageTopologyModel);
this.isOutageTopologyModelInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.OutageTopologyModel}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.CommandedElements)
{
this.commandedElements = await ReliableDictionaryAccess <long, CommandedElement> .Create(stateManager, ReliableDictionaryNames.CommandedElements);
this.isCommandedElementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.CommandedElements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableQueueNames.PotentialOutages)
{
this.potentialOutagesQueue = await ReliableQueueAccess <PotentialOutageCommand> .Create(stateManager, ReliableQueueNames.PotentialOutages);
this.isPotentialOutagesQueueInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableQueueNames.PotentialOutages}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.GidToPointItemMap)
{
gidToPointItemMap = await ReliableDictionaryAccess <long, IScadaModelPointItem> .Create(stateManager, ReliableDictionaryNames.GidToPointItemMap);
this.isGidToPointItemMapInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.GidToPointItemMap}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.MeasurementsCache)
{
measurementsCache = await ReliableDictionaryAccess <long, ModbusData> .Create(stateManager, ReliableDictionaryNames.MeasurementsCache);
this.isMeasurementsCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.MeasurementsCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.CommandDescriptionCache)
{
commandDescriptionCache = await ReliableDictionaryAccess <long, CommandDescription> .Create(stateManager, ReliableDictionaryNames.CommandDescriptionCache);
this.isCommandDescriptionCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.CommandDescriptionCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.InfoCache)
{
infoCache = await ReliableDictionaryAccess <string, bool> .Create(stateManager, ReliableDictionaryNames.InfoCache);
isInfoCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.InfoCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.HistoryModelChanges)
{
HistoryModelChanges = await ReliableDictionaryAccess <byte, List <long> > .Create(stateManager, ReliableDictionaryNames.HistoryModelChanges);
this.isHistoryModelChangesInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.HistoryModelChanges}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.OutageTopologyModel)
{
this.outageTopologyModel = await ReliableDictionaryAccess <string, OutageTopologyModel> .Create(stateManager, ReliableDictionaryNames.OutageTopologyModel);
this.isOutageTopologyModelInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.OutageTopologyModel}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.RegisteredSubscribersCache)
{
//_ = SubscriberCache;
registeredSubscribersCache = await ReliableDictionaryAccess <short, HashSet <string> > .Create(stateManager, ReliableDictionaryNames.RegisteredSubscribersCache);
isSubscriberCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.RegisteredSubscribersCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.OpenedSwitches)
{
openedSwitches = await ReliableDictionaryAccess <long, long> .Create(this.stateManager, ReliableDictionaryNames.OpenedSwitches);
this.isOpenedSwitchesInitialized = true;
}
else if (reliableStateName == ReliableDictionaryNames.UnenergizedConsumers)
{
unenergizedConsumers = await ReliableDictionaryAccess <long, long> .Create(this.stateManager, ReliableDictionaryNames.UnenergizedConsumers);
this.isUnenergizedConsumersInitialized = true;
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.OpenedSwitches)
{
OpenedSwitches = await ReliableDictionaryAccess <long, long> .Create(stateManager, ReliableDictionaryNames.OpenedSwitches);
this.isOpenedSwitchesInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.OpenedSwitches}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.UnenergizedConsumers)
{
UnenergizedConsumers = await ReliableDictionaryAccess <long, long> .Create(stateManager, ReliableDictionaryNames.UnenergizedConsumers);
this.isUnenergizedConsumersInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.UnenergizedConsumers}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.HistoryModelChanges)
{
HistoryModelChanges = await ReliableDictionaryAccess <byte, List <long> > .Create(stateManager, ReliableDictionaryNames.HistoryModelChanges);
this.isHistoryModelChangesInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.HistoryModelChanges}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async Task InitializeReliableCollections(NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.StartedIsolationAlgorithms)
{
this.startedIsolationAlgorithms = await ReliableDictionaryAccess <long, IsolationAlgorithm> .Create(stateManager, ReliableDictionaryNames.StartedIsolationAlgorithms);
this.isStartedIsolationAlgorithmsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.StartedIsolationAlgorithms}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.RecloserOutageMap)
{
this.recloserOutageMap = await ReliableDictionaryAccess <long, Dictionary <long, List <long> > > .Create(stateManager, ReliableDictionaryNames.RecloserOutageMap);
this.isRecloserOutageMapInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.RecloserOutageMap}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.OutageTopologyModel)
{
this.outageTopologyModel = await ReliableDictionaryAccess <string, OutageTopologyModel> .Create(stateManager, ReliableDictionaryNames.OutageTopologyModel);
this.isOutageTopologyModelInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.OutageTopologyModel}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.OptimumIsolationPoints)
{
this.optimumIsolationPoints = await ReliableDictionaryAccess <long, long> .Create(stateManager, ReliableDictionaryNames.OptimumIsolationPoints);
this.isOptimumIsolationPointsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.OptimumIsolationPoints}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.CommandedElements)
{
this.commandedElements = await ReliableDictionaryAccess <long, CommandedElement> .Create(stateManager, ReliableDictionaryNames.CommandedElements);
this.isCommandedElementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.CommandedElements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.ElementsToBeIgnoredInReportPotentialOutage)
{
this.elementsToBeIgnoredInReportPotentialOutage = await ReliableDictionaryAccess <long, DateTime> .Create(stateManager, ReliableDictionaryNames.ElementsToBeIgnoredInReportPotentialOutage);
this.isElementsToBeIgnoredInReportPotentialOutageInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.ElementsToBeIgnoredInReportPotentialOutage}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableQueueNames.PotentialOutages)
{
this.potentialOutagesQueue = await ReliableQueueAccess <PotentialOutageCommand> .Create(stateManager, ReliableQueueNames.PotentialOutages);
this.isPotentialOutagesQueueInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableQueueNames.PotentialOutages}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.GidToPointItemMap)
{
CurrentGidToPointItemMap = await ReliableDictionaryAccess <long, IScadaModelPointItem> .Create(stateManager, ReliableDictionaryNames.GidToPointItemMap);
this.isCurrentGidToPointItemMapInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.GidToPointItemMap}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.IncomingGidToPointItemMap)
{
IncomingGidToPointItemMap = await ReliableDictionaryAccess <long, IScadaModelPointItem> .Create(stateManager, ReliableDictionaryNames.IncomingGidToPointItemMap);
this.isIncomingGidToPointItemMapInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.IncomingGidToPointItemMap}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.AddressToGidMap)
{
CurrentAddressToGidMap = await ReliableDictionaryAccess <short, Dictionary <ushort, long> > .Create(stateManager, ReliableDictionaryNames.AddressToGidMap);
this.isCurrentAddressToGidMapInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.AddressToGidMap}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.IncomingAddressToGidMap)
{
IncomingAddressToGidMap = await ReliableDictionaryAccess <short, Dictionary <ushort, long> > .Create(stateManager, ReliableDictionaryNames.IncomingAddressToGidMap);
this.isIncomingAddressToGidMapInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.IncomingAddressToGidMap}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.InfoCache)
{
InfoCache = await ReliableDictionaryAccess <string, bool> .Create(stateManager, ReliableDictionaryNames.InfoCache);
isInfoCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.InfoCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.ModelChanges)
{
ModelChanges = await ReliableDictionaryAccess <byte, List <long> > .Create(stateManager, ReliableDictionaryNames.ModelChanges);
this.isModelChangesInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.ModelChanges}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.CommandDescriptionCache)
{
CommandDescriptionCache = await ReliableDictionaryAccess <long, CommandDescription> .Create(stateManager, ReliableDictionaryNames.CommandDescriptionCache);
this.isCommandDescriptionCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.CommandDescriptionCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.MeasurementsCache)
{
MeasurementsCache = await ReliableDictionaryAccess <long, ModbusData> .Create(stateManager, ReliableDictionaryNames.MeasurementsCache);
this.isMeasurementsCacheInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.MeasurementsCache}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}
private async void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
if (e.Action == NotifyStateManagerChangedAction.Add)
{
var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;
string reliableStateName = operation.ReliableState.Name.AbsolutePath;
if (reliableStateName == ReliableDictionaryNames.EnergySources)
{
this.energySources = await ReliableDictionaryAccess <string, List <long> > .Create(stateManager, ReliableDictionaryNames.EnergySources);
this.isEnergySourcesInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.EnergySources}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.Reclosers)
{
this.reclosers = await ReliableDictionaryAccess <string, HashSet <long> > .Create(stateManager, ReliableDictionaryNames.Reclosers);
this.isReclosersInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.Reclosers}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.Measurements)
{
this.measurements = await ReliableDictionaryAccess <long, IMeasurement> .Create(stateManager, ReliableDictionaryNames.Measurements);
this.isMeasurementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.Measurements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.TopologyElements)
{
this.topologyElements = await ReliableDictionaryAccess <long, ITopologyElement> .Create(stateManager, ReliableDictionaryNames.TopologyElements);
this.isTopologyElementsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.TopologyElements}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.BaseVoltages)
{
this.baseVoltages = await ReliableDictionaryAccess <long, float> .Create(stateManager, ReliableDictionaryNames.BaseVoltages);
this.isBaseVoltagesInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.BaseVoltages}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.ElementConnections)
{
this.elementConnections = await ReliableDictionaryAccess <long, List <long> > .Create(stateManager, ReliableDictionaryNames.ElementConnections);
this.isElementConnectionsInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.ElementConnections}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.MeasurementToConnectedTerminalMap)
{
this.measurementToConnectedTerminalMap = await ReliableDictionaryAccess <long, long> .Create(stateManager, ReliableDictionaryNames.MeasurementToConnectedTerminalMap);
this.isMeasurementToConnectedTerminalMapInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.MeasurementToConnectedTerminalMap}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
else if (reliableStateName == ReliableDictionaryNames.TerminalToConnectedElementsMap)
{
this.terminalToConnectedElementsMap = await ReliableDictionaryAccess <long, List <long> > .Create(stateManager, ReliableDictionaryNames.TerminalToConnectedElementsMap);
this.isTerminalToConnectedElementsMapInitialized = true;
string debugMessage = $"{baseLogString} OnStateManagerChangedHandler => '{ReliableDictionaryNames.TerminalToConnectedElementsMap}' ReliableDictionaryAccess initialized.";
Logger.LogDebug(debugMessage);
}
}
}