public override object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
if (values[0] is WpfObservableRangeCollection <Layer> layers && values[1] is LayerStructure structure)
{
if (cachedTree == null)
{
cachedTree = new StructuredLayerTree(layers, structure);
}
if (TryFindStructureDifferences(structure) ||
lastLayerGuids.Count != layers.Count ||
LayerOrderIsDifferent(layers) ||
LayersAreDifferentObjects(layers, lastLayers))
{
cachedTree = new StructuredLayerTree(layers, structure);
lastLayers = layers;
lastLayerGuids = layers.Select(x => x.GuidValue).ToList();
lastStructure = structure.CloneGroups();
}
return(cachedTree.RootDirectoryItems);
}
return(DependencyProperty.UnsetValue);
}
public WpfObservableRangeTree(WpfObservableRangeCollection <T> nodes) : base(nodes)
{
foreach (var treeNode in nodes.OfType <ITreeNode <T> >())
{
if (treeNode.Children is INotifyTreeChanged observableTree)
{
observableTree.TreeChanged += OnNodesTreeChanged;
}
}
}
/// <summary>
/// Deep clones groups.
/// </summary>
/// <param name="groups">Groups to clone.</param>
/// <returns>ObservableCollection with cloned groups.</returns>
public static WpfObservableRangeCollection <GuidStructureItem> CloneGroups(WpfObservableRangeCollection <GuidStructureItem> groups)
{
WpfObservableRangeCollection <GuidStructureItem> outputGroups = new();
foreach (var group in groups.ToArray())
{
outputGroups.Add(group.CloneGroup());
}
return(outputGroups);
}
private ObservableCollection <GuidStructureItem> GetSubGroups(IEnumerable <GuidStructureItem> groups)
{
WpfObservableRangeCollection <GuidStructureItem> finalGroups = new WpfObservableRangeCollection <GuidStructureItem>();
foreach (var group in groups)
{
finalGroups.AddRange(GetSubGroups(group));
}
return(finalGroups);
}
public async Task <WindowsService[]> ReadWindowsServiceDynamicDataAsync(
WpfObservableRangeCollection <WindowsService> windowsServiceDynamicObservableCollection,
WorkstationMonitorServiceClient workstationMonitorServiceClient,
CancellationToken cancellationToken)
{
WindowsService[] result = await workstationMonitorServiceClient.ReadWindowsServiceDynamicDataAsync();
if (result != null && !cancellationToken.IsCancellationRequested)
{
windowsServiceDynamicObservableCollection.ReplaceRange(result, new WindowsServiceComparer());
}
return(result);
}
private DynamicLineChartViewModel GetOrCreateNewLineChartIfNotExists(
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModel,
Sensor sensor,
string hardwareName)
{
DynamicLineChartViewModel chartViewModel = dynamicChartViewModel
.Where(x => x.ChartName == sensor.SensorType && x.HardwareName == hardwareName)
.SingleOrDefault();
if (chartViewModel == null)
{
chartViewModel = new DynamicLineChartViewModel(sensor.SensorType, hardwareName);
this.InvokeInUIThread((Action)(() => dynamicChartViewModel.Add(chartViewModel)));
}
return(chartViewModel);
}
public void DrawDynamicPieChartForHardwareSensor(
WpfObservableRangeCollection <DynamicPieChartViewModel> dynamicChartViewModel,
Sensor sensor,
string hardwareName)
{
if (sensor.Value == "No value")
{
return;
}
DynamicPieChartViewModel chartViewModel = this.GetOrCreateNewPieChartIfNotExists(dynamicChartViewModel, sensor, hardwareName);
this.AddNewValuesToDynamicViewLabels(chartViewModel, sensor);
// In case of "SmallData" sensor type, Open Hardware Monitor returns also total amount of data
// which is not requested by view
if (sensor.SensorType == "SmallData" && sensor.SensorName.ToLower().Contains("total"))
{
return;
}
this.AddNewPieChartSliceIfNotExists(sensor, chartViewModel);
this.RefreshValueInPieSeries(sensor, chartViewModel);
// Open Hardware Monitor defines load for hard disk as "Used Space" abd does not provide "Free Memoery Space"
// In order to display it as pie chart we need to define mocked sensor - "Not Used Space"
// to calculate not used memory part
if (sensor.SensorType == "Load" && sensor.Unit == "%" && sensor.SensorName == "Used Space")
{
Sensor notUsedMemoryMockedSensor = new Sensor()
{
Unit = "%",
SensorName = "Not Used Space",
SensorType = "Load",
Value = (100d - double.Parse(sensor.Value)).ToString(),
};
this.AddNewValuesToDynamicViewLabels(chartViewModel, notUsedMemoryMockedSensor);
this.AddNewPieChartSliceIfNotExists(notUsedMemoryMockedSensor, chartViewModel);
this.RefreshValueInPieSeries(notUsedMemoryMockedSensor, chartViewModel);
}
}
public IAsyncCommand CreateWindowsServiceDynamicDataCommand(WpfObservableRangeCollection <WindowsService> windowsService)
{
return(new AsyncCommand <bool>(async(cancellationToken) =>
{
return await Task.Run(async() =>
{
WorkstationMonitorServiceClient workstationMonitorServiceClient = null;
bool result = false;
try
{
workstationMonitorServiceClient = await this.wcfClient.GetNewWorkstationMonitorServiceClient();
// Set the task.
var neverEndingTask = this.tPLFactory.CreateNeverEndingTaskMakingWcfCalls(
(now, ct, client) => this.wcfClient.ReadWindowsServiceDynamicDataAsync(windowsService, client, ct)
.WithCancellation(ct),
cancellationToken,
this.configProvider.DelayBetweenCalls_WindowsService,
this.wcfClient.MachineIdentifier,
workstationMonitorServiceClient);
// Start the task. Post the time.
result = neverEndingTask.Post(DateTimeOffset.Now);
// if cancel was not requested task is still ongoing
while (!cancellationToken.IsCancellationRequested)
{
await Task.Delay(this.neverEndingCommandDelayInMiliSeconds);
}
}
catch (InvalidOperationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
}
return result;
});
}));
}
public void DrawDynamicLineChartForHardwareSensor(
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModel,
Sensor sensor,
string hardwareName)
{
// In case of "No Value" returned from SystemManagamentLib do not generate charts
if (sensor.Value == "No value")
{
return;
}
DynamicLineChartViewModel chartViewModel = this.GetOrCreateNewLineChartIfNotExists(dynamicChartViewModel, sensor, hardwareName);
this.AddNewValuesToDynamicViewLabels(chartViewModel, sensor);
this.AddNewLineSeriesIfNotExists(sensor, chartViewModel);
this.AdjustChartValuesRange(sensor, chartViewModel);
this.AddNewValuesToLineSeries(sensor, chartViewModel);
chartViewModel.SetAxisLimits(DateTime.Now);
}
public LayerStructure(Document owner)
{
Groups = new WpfObservableRangeCollection <GuidStructureItem>();
Owner = owner;
}
public LayerStructure(WpfObservableRangeCollection <GuidStructureItem> items, Document owner)
{
Groups = items;
Owner = owner;
}
public async Task <HardwareDynamicData> ReadHardwareDynamicDataAsync(
WpfObservableRangeCollection <HardwareDynamicData> hardwareDynamicObservableCollection,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorClock,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorPower,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorTemp,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorLoad,
WpfObservableRangeCollection <DynamicPieChartViewModel> dynamicChartViewModelDiskLoad,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelDiskTemp,
WpfObservableRangeCollection <DynamicPieChartViewModel> dynamicChartViewModelMemoryData,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPULoad,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUTemp,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUClock,
WpfObservableRangeCollection <DynamicPieChartViewModel> dynamicChartViewModelGPUData,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUVoltage,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUFan,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelMainBoardTemp,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelMainBoardFan,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelMainBoardVoltage,
bool logsEnabled,
string logsDirectoryPath,
WorkstationMonitorServiceClient workstationMonitorServiceClient,
CancellationToken cancellationToken)
{
HardwareDynamicData result = await workstationMonitorServiceClient.ReadHardwareDynamicDataAsync();
if (result != null && !cancellationToken.IsCancellationRequested)
{
string fileName = string.Empty;
foreach (var processor in result.Processor)
{
fileName = this.GenerateLogFileNameForSensor(logsDirectoryPath, "CPU");
foreach (var load in processor.Load)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelProcessorLoad, load, processor.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, load);
}
foreach (var clock in processor.Clock)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelProcessorClock, clock, processor.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, clock);
}
foreach (var power in processor.Power)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelProcessorPower, power, processor.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, power);
}
foreach (var temperature in processor.Temperature)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelProcessorTemp, temperature, processor.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, temperature);
}
}
foreach (var disk in result.Disk)
{
fileName = this.GenerateLogFileNameForSensor(logsDirectoryPath, "DISK");
foreach (var load in disk.Load)
{
this.dynamicDataHelper.DrawDynamicPieChartForHardwareSensor(dynamicChartViewModelDiskLoad, load, disk.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, load);
}
foreach (var temperature in disk.Temperature)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelDiskTemp, temperature, disk.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, temperature);
}
}
foreach (var memory in result.Memory)
{
fileName = this.GenerateLogFileNameForSensor(logsDirectoryPath, "MEMORY");
foreach (var data in memory.Data)
{
this.dynamicDataHelper.DrawDynamicPieChartForHardwareSensor(dynamicChartViewModelMemoryData, data, memory.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, data);
}
}
foreach (var gpu in result.VideoController)
{
fileName = this.GenerateLogFileNameForSensor(logsDirectoryPath, "GPU");
foreach (var load in gpu.Load)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelGPULoad, load, gpu.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, load);
}
foreach (var temperature in gpu.Temperature)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelGPUTemp, temperature, gpu.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, temperature);
}
foreach (var clock in gpu.Clock)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelGPUClock, clock, gpu.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, clock);
}
foreach (var data in gpu.Data)
{
this.dynamicDataHelper.DrawDynamicPieChartForHardwareSensor(dynamicChartViewModelGPUData, data, gpu.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, data);
}
foreach (var voltage in gpu.Voltage)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelGPUVoltage, voltage, gpu.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, voltage);
}
foreach (var fan in gpu.Fan)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelGPUFan, fan, gpu.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, fan);
}
}
foreach (var mainBoard in result.MainBoard)
{
fileName = this.GenerateLogFileNameForSensor(logsDirectoryPath, "MAINBOARD");
foreach (var temperature in mainBoard.Temperature)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelMainBoardTemp, temperature, mainBoard.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, temperature);
}
foreach (var fan in mainBoard.Fan)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelMainBoardFan, fan, mainBoard.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, fan);
}
foreach (var voltage in mainBoard.Voltage)
{
this.dynamicDataHelper.DrawDynamicLineChartForHardwareSensor(dynamicChartViewModelMainBoardVoltage, voltage, mainBoard.Name);
this.LogSensorValueIfRequested(logsEnabled, fileName, voltage);
}
}
}
return(result);
}
public IAsyncCommand CreateSoftwareStaticDataCommand(
WpfObservableRangeCollection <CurrentUser> currentUser,
WpfObservableRangeCollection <OS> operatingSystem,
WpfObservableRangeCollection <Bios> bios,
WpfObservableRangeCollection <InstalledProgram> installedProgram,
WpfObservableRangeCollection <MicrosoftWindowsUpdate> microsoftWindowsUpdate,
WpfObservableRangeCollection <StartupCommand> startupCommand,
WpfObservableRangeCollection <LocalUser> localUser)
{
return(new AsyncCommand <SoftwareStaticData>(async(cancellationToken) =>
{
return await Task.Run(async() =>
{
WorkstationMonitorServiceClient workstationMonitorServiceClient = null;
SoftwareStaticData result = null;
try
{
workstationMonitorServiceClient = await this.wcfClient.GetNewWorkstationMonitorServiceClient();
result = await this.wcfClient.ReadSoftwareStaticDataAsync(workstationMonitorServiceClient)
.WithCancellation(cancellationToken)
// Following statements will be processed in the same thread, won't use caught context (UI)
.ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
workstationMonitorServiceClient.Abort();
}
else
{
workstationMonitorServiceClient.Close();
}
if (result != null && !cancellationToken.IsCancellationRequested)
{
currentUser.ReplaceRange(result.CurrentUser, new CurrentUserStaticComparer());
operatingSystem.ReplaceRange(result.OperatingSystem, new OSComparer());
bios.ReplaceRange(result.Bios, new BiosComparer());
installedProgram.ReplaceRange(result.InstalledProgram, new InstalledProgramComparer());
microsoftWindowsUpdate.ReplaceRange(result.MicrosoftWindowsUpdate, new MicrosoftWindowsUpdateComparer());
startupCommand.ReplaceRange(result.StartupCommand, new StartupCommandComparer());
localUser.ReplaceRange(result.LocalUser, new LocalUserComparer());
}
}
catch (InvalidOperationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
// Rethrow exception in order to set correct Task state (Faulted)
throw;
}
catch (EndpointNotFoundException)
{
this.messageSender.SendErrorMessageEndpointNotFound();
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
catch (TimeoutException)
{
this.messageSender.SendErrorMessageTimeout();
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
catch (CommunicationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
return result;
});
}));
}
public IAsyncCommand CreateHardwareStaticDataCommand(
WpfObservableRangeCollection <ProcessorStatic> processorStatic,
WpfObservableRangeCollection <ProcessorCache> processorCache,
WpfObservableRangeCollection <Memory> memoryItems,
WpfObservableRangeCollection <BaseBoard> baseBoard,
WpfObservableRangeCollection <VideoController> videoController,
WpfObservableRangeCollection <NetworkAdapter> networkAdapter,
WpfObservableRangeCollection <PnPEntity> pnPEntity,
WpfObservableRangeCollection <CDROMDrive> cDROMDrive,
WpfObservableRangeCollection <Fan> fan,
WpfObservableRangeCollection <Printer> printer,
WpfObservableRangeCollection <Battery> battery,
WpfObservableRangeCollection <Storage> storage)
{
return(new AsyncCommand <HardwareStaticData>(async(cancellationToken) =>
{
WorkstationMonitorServiceClient workstationMonitorServiceClient = null;
HardwareStaticData result = null;
try
{
workstationMonitorServiceClient = await this.wcfClient.GetNewWorkstationMonitorServiceClient();
result = await Task.Run <HardwareStaticData>(() => workstationMonitorServiceClient.ReadHardwareStaticDataAsync())
.WithCancellation(cancellationToken)
// Following statements will be processed in the same thread, won't use caught context (UI)
.ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
workstationMonitorServiceClient.Abort();
}
else
{
workstationMonitorServiceClient.Close();
}
if (result != null && !cancellationToken.IsCancellationRequested)
{
processorStatic.ReplaceRange(result.Processor, new ProcessorStaticComparer());
processorCache.ReplaceRange(result.ProcessorCache, new ProcessorCacheStaticComparer());
memoryItems.ReplaceRange(result.Memory, new MemoryStaticComparer());
baseBoard.ReplaceRange(result.BaseBoard, new BaseBoardStaticComparer());
videoController.ReplaceRange(result.VideoController, new VideoControllerStaticComparer());
networkAdapter.ReplaceRange(result.NetworkAdapter, new NetworkAdapterStaticComparer());
pnPEntity.ReplaceRange(result.PnPEntity, new PnPEntityStaticComparer());
cDROMDrive.ReplaceRange(result.CDROMDrive, new CDROMDriveStaticComparer());
fan.ReplaceRange(result.Fan, new FanStaticComparer());
printer.ReplaceRange(result.Printer, new PrinterStaticComparer());
battery.ReplaceRange(result.Battery, new BatteryStaticComparer());
storage.ReplaceRange(result.Storage);
}
}
catch (InvalidOperationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
// Rethrow exception in order to set correct Task state (Faulted)
throw;
}
catch (EndpointNotFoundException)
{
this.messageSender.SendErrorMessageEndpointNotFound();
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
catch (TimeoutException)
{
this.messageSender.SendErrorMessageTimeout();
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
catch (CommunicationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
return result;
}));
}
public IAsyncCommand CreateHardwareDynamicDataCommand(
WpfObservableRangeCollection <HardwareDynamicData> hardwareDynamic,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorClock,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorPower,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorTemp,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelProcessorLoad,
WpfObservableRangeCollection <DynamicPieChartViewModel> dynamicChartViewModelDiskLoad,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelDiskTemp,
WpfObservableRangeCollection <DynamicPieChartViewModel> dynamicChartViewModelMemoryData,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPULoad,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUTemp,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUClock,
WpfObservableRangeCollection <DynamicPieChartViewModel> dynamicChartViewModelGPUData,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUVoltage,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelGPUFan,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelMainBoardTemp,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelMainBoardFan,
WpfObservableRangeCollection <DynamicLineChartViewModel> dynamicChartViewModelMainBoardVoltage,
string machineName)
{
return(new AsyncCommandParameterized <bool>(
async(cancellationToken, nameOfMachine) =>
{
return await Task.Run(async() =>
{
WorkstationMonitorServiceClient workstationMonitorServiceClient = null;
bool result = false;
try
{
workstationMonitorServiceClient = await this.wcfClient.GetNewWorkstationMonitorServiceClient();
bool logsEnabled = false;
DirectoryInfo logsDirectory = null;
if (this.configProvider.DynamicHardwareLogs_Include)
{
string logsPath = this.configProvider.DynamicHardwareLogs_Path;
if (!string.IsNullOrEmpty(logsPath))
{
string directoryName = nameOfMachine + "_Hardware_Dynamic_Logs\\";
logsDirectory = Directory.CreateDirectory(logsPath + directoryName);
logsEnabled = true;
}
}
string logsDirectoryPath = logsDirectory?.FullName ?? string.Empty;
// Set the task.
var neverEndingTask = this.tPLFactory.CreateNeverEndingTaskMakingWcfCalls(
(now, ct, client) => this.wcfClient.ReadHardwareDynamicDataAsync(
hardwareDynamic,
dynamicChartViewModelProcessorClock,
dynamicChartViewModelProcessorPower,
dynamicChartViewModelProcessorTemp,
dynamicChartViewModelProcessorLoad,
dynamicChartViewModelDiskLoad,
dynamicChartViewModelDiskTemp,
dynamicChartViewModelMemoryData,
dynamicChartViewModelGPULoad,
dynamicChartViewModelGPUTemp,
dynamicChartViewModelGPUClock,
dynamicChartViewModelGPUData,
dynamicChartViewModelGPUVoltage,
dynamicChartViewModelGPUFan,
dynamicChartViewModelMainBoardTemp,
dynamicChartViewModelMainBoardFan,
dynamicChartViewModelMainBoardVoltage,
logsEnabled,
logsDirectoryPath,
client,
ct)
.WithCancellation(ct),
cancellationToken,
this.configProvider.DelayBetweenCalls_HardwareDynamic,
this.wcfClient.MachineIdentifier,
workstationMonitorServiceClient);
// Start the task. Post the time.
result = neverEndingTask.Post(DateTimeOffset.Now);
// if cancel was not requested task is still ongoing
while (!cancellationToken.IsCancellationRequested)
{
await Task.Delay(this.neverEndingCommandDelayInMiliSeconds);
}
}
catch (Exception ex)
{
this.messageSender.SendErrorMessage(ex.Message);
}
return result;
});
}, machineName));
}
public IAsyncCommand CreateWindowsLogDynamicDataCommand(WpfObservableRangeCollection <WindowsLog> windowsLog)
{
return(new AsyncCommand <WindowsLog[]>(async(cancellationToken) =>
{
WorkstationMonitorServiceClient workstationMonitorServiceClient = null;
WindowsLog[] result = null;
try
{
workstationMonitorServiceClient = await this.wcfClient.GetNewWorkstationMonitorServiceClient();
result = await this.wcfClient.ReadWindowsLogDynamicDataAsync(workstationMonitorServiceClient)
.WithCancellation(cancellationToken)
// Following statements will be processed in the same thread, won't use caught context (UI)
.ConfigureAwait(false);
if (cancellationToken.IsCancellationRequested)
{
workstationMonitorServiceClient.Abort();
}
else
{
workstationMonitorServiceClient.Close();
}
if (result != null && !cancellationToken.IsCancellationRequested)
{
windowsLog.ReplaceRange(result, new WindowsLogComparer());
}
}
catch (InvalidOperationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
// Rethrow exception in order to set correct Task state (Faulted)
throw;
}
catch (EndpointNotFoundException)
{
this.messageSender.SendErrorMessageEndpointNotFound();
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
catch (TimeoutException)
{
this.messageSender.SendErrorMessageTimeout();
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
catch (CommunicationException ex)
{
this.messageSender.SendErrorMessage(ex.Message);
this.messageSender.SendCancelCommandMessage(this.wcfClient.MachineIdentifier);
workstationMonitorServiceClient.Abort();
throw;
}
return result;
}));
}
