private Task ExcludePairToStrategy(PairOfMarket pair, TimeframeType timeframe, int barCount)
{
return(Task.Run(() =>
{
Model.ExcludePairFromStrategy(pair, timeframe, barCount);
}));
}
public static int TimeFrameToSeconds(TimeframeType timeframe)
{
switch (timeframe)
{
case TimeframeType.M5:
return(300);
case TimeframeType.M15:
return(900);
case TimeframeType.M30:
return(1800);
case TimeframeType.H2:
return(7200);
case TimeframeType.H4:
return(14400);
case TimeframeType.D1:
return(86400);
default:
throw new ArgumentOutOfRangeException(nameof(timeframe), timeframe, null);
}
}
public Task RunPerformanceAsync(string name,
PerformanceCounterType performanceCounterType,
TimeframeType timeframeType,
IProgress <Tuple <PerformanceCounterType, PerfCounterModel> > progress)
{
throw new NotImplementedException();
}
public Timeframe(TimeframeType timeframeType, DateTime timeFrameDateTime)
{
this.timeframeType = timeframeType;
switch (timeframeType)
{
case TimeframeType.Date:
this.timeframeDateTime = new DateTime(timeFrameDateTime.Year, timeFrameDateTime.Month, timeFrameDateTime.Day);
break;
case TimeframeType.Time:
this.timeframeDateTime = new DateTime(timeFrameDateTime.Year, timeFrameDateTime.Month, timeFrameDateTime.Day,
timeFrameDateTime.Hour, timeFrameDateTime.Minute, 0);
break;
case TimeframeType.Week:
this.timeframeDateTime = new DateTime(timeFrameDateTime.Year, timeFrameDateTime.Month, timeFrameDateTime.Day)
.StartOfWeek(DayOfWeek.Monday);
break;
case TimeframeType.Month:
this.timeframeDateTime = new DateTime(timeFrameDateTime.Year, timeFrameDateTime.Month, 1);
break;
default:
this.timeframeDateTime = new DateTime(2050, 1, 1);
break;
}
}
public static int ToMinutes(this TimeframeType timeframe)
{
switch (timeframe)
{
case TimeframeType.M1:
return(1);
case TimeframeType.M5:
return(5);
case TimeframeType.M15:
return(15);
case TimeframeType.M30:
return(30);
case TimeframeType.H1:
return(60);
case TimeframeType.H2:
return(120);
case TimeframeType.H4:
return(240);
case TimeframeType.D1:
return(1440);
default:
throw new ArgumentOutOfRangeException(nameof(timeframe), timeframe, null);
}
}
public async Task RunPerformanceAsync(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType, IProgress<Tuple<PerformanceCounterType, PerfCounterModel>> progress)
{
await Task.Run(async () =>
{
var random = new Random();
int prevPoint = 0;
while (true)
{
await Task.Yield();
int point = prevPoint > 0 ? prevPoint : startPoint;
// Update the point price by a random factor of the range percent
int number = (point + (int)(random.NextDouble() * random.Next(0, 30))) - random.Next(0, 50);
if (number < minPoint)
{
number = random.Next(0, 10);
}
else if (number > maxPoint)
{
number = 100;
}
progress.Report(new Tuple<PerformanceCounterType, PerfCounterModel>(performanceCounterType, new PerfCounterModel { Timestamp = DateTime.Now, Value = number }));
await Task.Delay(250);
prevPoint = number;
}
}).ConfigureAwait(false);
}
public IEnumerable <HistoryPrice> MarketHistoryData(Pair pair, TimeframeType timeframe, DateTime?startTime = null)
{
if (!startTime.HasValue)
{
startTime = DateTime.MinValue;
}
return(MarketHistoryData(pair, timeframe, new TimeRange(startTime.Value, DateTime.Now)));
}
/// <summary>
/// To be used in the market analyzer to indicate number of periods since the fast crossed the slow MA. Negative reflects periods since the fast crossed below the slow MA.
/// </summary>
/// <returns></returns>
public Indicator.MACross MACross(Data.IDataSeries input, TimeframeType timeframe)
{
if (InInitialize && input == null)
{
throw new ArgumentException("You only can access an indicator with the default input/bar series from within the 'Initialize()' method");
}
return(_indicator.MACross(input, timeframe));
}
public void IncludePairToStrategy(PairOfMarket pair, TimeframeType timeframe, int barCount)
{
_pairs.Add(pair);
var updater = HistoryPricesProvider.GetUpdater(MakeFeature(pair, timeframe, barCount), _refreshInterval);
updater.Changed += Updater_Changed;
updater.Start();
_updaters.Add(updater);
}
/// <summary>
/// To be used in the market analyzer to indicate number of periods since the fast crossed the slow MA. Negative reflects periods since the fast crossed below the slow MA.
/// </summary>
/// <returns></returns>
public MACross MACross(Data.IDataSeries input, TimeframeType timeframe)
{
if (cacheMACross != null)
{
for (int idx = 0; idx < cacheMACross.Length; idx++)
{
if (cacheMACross[idx].Timeframe == timeframe && cacheMACross[idx].EqualsInput(input))
{
return(cacheMACross[idx]);
}
}
}
lock (checkMACross)
{
checkMACross.Timeframe = timeframe;
timeframe = checkMACross.Timeframe;
if (cacheMACross != null)
{
for (int idx = 0; idx < cacheMACross.Length; idx++)
{
if (cacheMACross[idx].Timeframe == timeframe && cacheMACross[idx].EqualsInput(input))
{
return(cacheMACross[idx]);
}
}
}
MACross indicator = new MACross();
indicator.BarsRequired = BarsRequired;
indicator.CalculateOnBarClose = CalculateOnBarClose;
#if NT7
indicator.ForceMaximumBarsLookBack256 = ForceMaximumBarsLookBack256;
indicator.MaximumBarsLookBack = MaximumBarsLookBack;
#endif
indicator.Input = input;
indicator.Timeframe = timeframe;
Indicators.Add(indicator);
indicator.SetUp();
MACross[] tmp = new MACross[cacheMACross == null ? 1 : cacheMACross.Length + 1];
if (cacheMACross != null)
{
cacheMACross.CopyTo(tmp, 0);
}
tmp[tmp.Length - 1] = indicator;
cacheMACross = tmp;
return(indicator);
}
}
//public IEnumerable<PairOfMarket> ActivePairs => _pairs;
public void ExcludePairFromStrategy(PairOfMarket pair, TimeframeType timeframe, int barCount)
{
var updater = _updaters.FirstOrDefault(u => u.OwnerFeature == MakeFeature(pair, timeframe, barCount));
if (updater == null)
{
return;
}
_pairs.Remove(pair);
updater.Changed -= Updater_Changed;
HistoryPricesProvider.ReleaseUpdater(updater);
_updaters.Remove(updater);
}
public async Task<int> GetPerformanceMeanValue(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType)
{
var random = new Random();
random.NextDouble();
var numbers = new List<int>();
for (int i = 0; i < 100; i++)
{
await Task.Yield();
int number = random.Next(0, 100);
numbers.Insert(i, number);
}
return numbers.Sum() / numbers.Count;
}
public IEnumerable <HistoryPrice> MarketHistoryData(Pair pair, TimeframeType timeframe, TimeRange timeRange)
{
var start = _timeCorrector.ToMarketTime(timeRange.Start);
var finish = _timeCorrector.ToMarketTime(timeRange.Finish);
var parameters = new Tuple <string, string> [5];
parameters[0] = new Tuple <string, string>(EndPoints.CommandTag, EndPoints.GetHistoryData);
parameters[1] = new Tuple <string, string>("currencyPair", PoloniexPairs.AsString(pair));
parameters[2] = new Tuple <string, string>("start", PoloniexTools.DateTimeToUnixTimeStamp(start).ToString());
parameters[3] = new Tuple <string, string>("end", PoloniexTools.DateTimeToUnixTimeStamp(finish).ToString());
parameters[4] = new Tuple <string, string>("period", PoloniexTools.TimeFrameToSeconds(timeframe).ToString());
var query = Connection.PublicGetQuery <List <PoloniexHistoryDataType> >(EndPoints.Public, parameters);
return(query.Select(item => item.ToHistory(pair)));
}
public async Task RunPerformanceAsync(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType, IProgress<Tuple<PerformanceCounterType, PerfCounterModel>> progress)
{
await Task.Run(async () =>
{
while (true)
{
await Task.Yield();
var value = await GetPerformanceMeanValue(name, performanceCounterType, timeframeType);
progress.Report(
new Tuple<PerformanceCounterType, PerfCounterModel>(performanceCounterType, new PerfCounterModel { Timestamp = DateTime.Now, Value = value }));
await Task.Delay(250);
}
}).ConfigureAwait(false);
}
public async Task<int> GetPerformanceMeanValue(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType)
{
string command = String
.Concat(String.Format(this.mainCommandTemplate, name), Environment.NewLine, "Get-SCPerformanceData -VM $VM -PerformanceCounter {0} -Timeframe {1}");
command = String.Format(command, performanceCounterType, timeframeType);
var mapper = new ChartMapper();
var objects = await this.psProvider.ExecuteAsync<PSObject>(new PSCommand { ScriptCommand = command });
var listValues = objects.Select(mapper.Map).ToList();
int meanValue = 0;
if (listValues.Any())
{
var result = listValues.ToList()[0].History;
meanValue = result.Sum() / result.Length;
}
return meanValue > 0 ? meanValue / 100 : 0;
}
public async Task<IEnumerable<PerfCounterModel>> GetPerformance(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType)
{
var random = new Random();
random.NextDouble();
var numbers = new List<PerfCounterModel>();
for (int i = 0; i < 2; i++)
{
await Task.Yield();
int number = performanceCounterType == PerformanceCounterType.CPUUsage
? random.Next(0, 100) : performanceCounterType == PerformanceCounterType.NetworkIOUsage
? random.Next(0, 5000) : random.Next(0, 1000000);
numbers.Insert(i, new PerfCounterModel
{
Timestamp = DateTime.Now,
Value = number
});
}
return numbers;
}
public async Task<IEnumerable<PerfCounterModel>> GetPerformance(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType)
{
string command = String
.Concat(String.Format(this.mainCommandTemplate, name), Environment.NewLine, "Get-SCPerformanceData -VM $VM -PerformanceCounter {0} -Timeframe {1}");
command = String.Format(command, performanceCounterType, timeframeType);
var mapper = new ChartMapper();
var objects = await this.psProvider.ExecuteAsync<PSObject>(new PSCommand { ScriptCommand = command });
var listValues = objects.Select(mapper.Map).ToList();
if (listValues.Any())
{
var perfCounter = listValues.ToList()[0];
var timestamps = perfCounter.TimeSamples;
var values = perfCounter.History;
return values.Select((t, i) => new PerfCounterModel { Value = t, Timestamp = timestamps[i] }).ToList();
}
return Enumerable.Empty<PerfCounterModel>();
}
public Task <int> GetPerformanceMeanValue(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType)
{
throw new NotImplementedException();
}
public async Task<IEnumerable<PerfCounterModel>> GetPerformance(
string name,
PerformanceCounterType performanceCounterType,
TimeframeType timeframeType)
{
var values = Enumerable.Empty<PerfCounterModel>();
var pVMs = new DynamicParameters();
pVMs.Add("ObjectType", 1);
pVMs.Add("error", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
var command = new DapperCommand
{
Name = "[dbo].[prc_WLC_GetAllVMsWithChildrenByType]",
Parametrs = pVMs,
Type = CommandType.StoredProcedure
};
var result = await this.provider.ExecuteAsync<VirtualMachineModel>(command);
var virtualMachineModels = result as IList<VirtualMachineModel> ?? result.ToList();
if (virtualMachineModels.Any())
{
foreach (var vm in virtualMachineModels)
{
if (vm.Name.Equals(name))
{
switch (performanceCounterType)
{
case PerformanceCounterType.CPUUsage:
{
var p = new DynamicParameters();
p.Add("tieredPerfCounterID", vm.CPUTieredPerfCounterID, DbType.Guid, ParameterDirection.Input);
p.Add("aggregationLevel", (int)timeframeType, DbType.Int32, ParameterDirection.Input);
p.Add("error", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
var commandPerfCPU = new DapperCommand
{
Name = "[dbo].[prc_PCMT_PerfHistory_Get]",
Parametrs = p,
Type = CommandType.StoredProcedure
};
var cpuValues = await this.provider.ExecuteAsync<PerfCounterModel>(commandPerfCPU);
values = cpuValues.OrderBy(t => t.Timestamp).ToList();
}
break;
case PerformanceCounterType.NetworkIOUsage:
{
var readParams = new DynamicParameters();
readParams.Add("tieredPerfCounterID", vm.NetworkBytesReadTieredPerfCounterID, DbType.Guid, ParameterDirection.Input);
readParams.Add("aggregationLevel", (int)timeframeType, DbType.Int32, ParameterDirection.Input);
readParams.Add("error", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
var commandPerfReadNet = new DapperCommand
{
Name = "[dbo].[prc_PCMT_PerfHistory_Get]",
Parametrs = readParams,
Type = CommandType.StoredProcedure
};
var readNetValues = await this.provider.ExecuteAsync<PerfCounterModel>(commandPerfReadNet);
var writeParams = new DynamicParameters();
writeParams.Add("tieredPerfCounterID", vm.NetworkBytesWriteTieredPerfCounterID, DbType.Guid, ParameterDirection.Input);
writeParams.Add("aggregationLevel", (int)timeframeType, DbType.Int32, ParameterDirection.Input);
writeParams.Add("error", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
var commandPerfWriteNet = new DapperCommand
{
Name = "[dbo].[prc_PCMT_PerfHistory_Get]",
Parametrs = writeParams,
Type = CommandType.StoredProcedure
};
var writeNetValues = await this.provider.ExecuteAsync<PerfCounterModel>(commandPerfWriteNet);
values = readNetValues.Union(writeNetValues)
//.Select(t => new PerfCounterModel { Value = t.Value / 1000, Timestamp = t.Timestamp })
.OrderBy(t => t.Timestamp)
.ToList();
}
break;
case PerformanceCounterType.StorageIOPSUsage:
{
var readParams = new DynamicParameters();
readParams.Add("tieredPerfCounterID", vm.DiskBytesReadTieredPerfCounterID, DbType.Guid, ParameterDirection.Input);
readParams.Add("aggregationLevel", (int)timeframeType, DbType.Int32, ParameterDirection.Input);
readParams.Add("error", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
var commandPerfReadStorage = new DapperCommand
{
Name = "[dbo].[prc_PCMT_PerfHistory_Get]",
Parametrs = readParams,
Type = CommandType.StoredProcedure
};
var readDiskValues = await this.provider.ExecuteAsync<PerfCounterModel>(commandPerfReadStorage);
var writeParams = new DynamicParameters();
writeParams.Add("tieredPerfCounterID", vm.DiskBytesWriteTieredPerfCounterID, DbType.Guid, ParameterDirection.Input);
writeParams.Add("aggregationLevel", (int)timeframeType, DbType.Int32, ParameterDirection.Input);
writeParams.Add("error", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
var commandPerfWriteStorage = new DapperCommand
{
Name = "[dbo].[prc_PCMT_PerfHistory_Get]",
Parametrs = writeParams,
Type = CommandType.StoredProcedure
};
var writeDiskValues = await this.provider.ExecuteAsync<PerfCounterModel>(commandPerfWriteStorage);
values = readDiskValues.Union(writeDiskValues)
//.Select(t => new PerfCounterModel { Value = t.Value / 10000, Timestamp = t.Timestamp })
.OrderBy(t => t.Timestamp)
.ToList();
}
break;
}
break;
}
}
}
return values;
}
public Timeframe()
{
this.timeframeType = TimeframeType.Open;
this.timeframeDateTime = new DateTime(2050, 1, 1); //Set date due to far off into the future
}
public Task<int> GetPerformanceMeanValue(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType)
{
throw new NotImplementedException();
}
public Task RunPerformanceAsync(string name,
PerformanceCounterType performanceCounterType,
TimeframeType timeframeType,
IProgress<Tuple<PerformanceCounterType, PerfCounterModel>> progress)
{
throw new NotImplementedException();
}
public HistoryPriceFeature(PairOfMarket pair, TimeframeType timeframe)
{
Pair = pair;
Timeframe = timeframe;
StartTime = null;
}
/// <summary>
/// To be used in the market analyzer to indicate number of periods since the fast crossed the slow MA. Negative reflects periods since the fast crossed below the slow MA.
/// </summary>
/// <returns></returns>
public Indicator.MACross MACross(Data.IDataSeries input, TimeframeType timeframe)
{
return(_indicator.MACross(input, timeframe));
}
public async Task <IEnumerable <PerfCounterModel> > GetPerformance(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType)
{
string command = String
.Concat(String.Format(this.mainCommandTemplate, name), Environment.NewLine, "Get-SCPerformanceData -VM $VM -PerformanceCounter {0} -Timeframe {1}");
command = String.Format(command, performanceCounterType, timeframeType);
var mapper = new ChartMapper();
var objects = await this.psProvider.ExecuteAsync <PSObject>(new PSCommand { ScriptCommand = command });
var listValues = objects.Select(mapper.Map).ToList();
if (listValues.Any())
{
var perfCounter = listValues.ToList()[0];
var timestamps = perfCounter.TimeSamples;
var values = perfCounter.History;
return(values.Select((t, i) => new PerfCounterModel {
Value = t, Timestamp = timestamps[i]
}).ToList());
}
return(Enumerable.Empty <PerfCounterModel>());
}
/// <summary>
/// To be used in the market analyzer to indicate number of periods since the fast crossed the slow MA. Negative reflects periods since the fast crossed below the slow MA.
/// </summary>
/// <returns></returns>
public MACross MACross(TimeframeType timeframe)
{
return(MACross(Input, timeframe));
}
public IEnumerable <HistoryPrice> MarketHistoryData(Pair pair, TimeframeType timeframe, TimeRange timeRange)
{
return(Enumerable.Empty <HistoryPrice>());
}
public async Task <int> GetPerformanceMeanValue(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType)
{
string command = String
.Concat(String.Format(this.mainCommandTemplate, name), Environment.NewLine, "Get-SCPerformanceData -VM $VM -PerformanceCounter {0} -Timeframe {1}");
command = String.Format(command, performanceCounterType, timeframeType);
var mapper = new ChartMapper();
var objects = await this.psProvider.ExecuteAsync <PSObject>(new PSCommand { ScriptCommand = command });
var listValues = objects.Select(mapper.Map).ToList();
int meanValue = 0;
if (listValues.Any())
{
var result = listValues.ToList()[0].History;
meanValue = result.Sum() / result.Length;
}
return(meanValue > 0 ? meanValue / 100 : 0);
}
public async Task RunPerformanceAsync(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType, IProgress <Tuple <PerformanceCounterType, PerfCounterModel> > progress)
{
await Task.Run(async() =>
{
while (true)
{
await Task.Yield();
var value = await GetPerformanceMeanValue(name, performanceCounterType, timeframeType);
progress.Report(
new Tuple <PerformanceCounterType, PerfCounterModel>(performanceCounterType, new PerfCounterModel {
Timestamp = DateTime.Now, Value = value
}));
await Task.Delay(250);
}
}).ConfigureAwait(false);
}
public HistoryPriceFeature(PairOfMarket pair, TimeframeType timeframe, int barCount) : this(pair, timeframe)
{
var minutes = timeframe.ToMinutes() * barCount;
StartTime = DateTime.Now.Subtract(new TimeSpan(0, minutes, 0));
}
public async Task <IEnumerable <PerfCounterModel> > GetPerformance(
string name,
PerformanceCounterType performanceCounterType,
TimeframeType timeframeType)
{
var values = Enumerable.Empty <PerfCounterModel>();
var pVMs = new DynamicParameters();
pVMs.Add("ObjectType", 1);
pVMs.Add("error", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
var command = new DapperCommand
{
Name = "[dbo].[prc_WLC_GetAllVMsWithChildrenByType]",
Parametrs = pVMs,
Type = CommandType.StoredProcedure
};
var result = await this.provider.ExecuteAsync <VirtualMachineModel>(command);
var virtualMachineModels = result as IList <VirtualMachineModel> ?? result.ToList();
if (virtualMachineModels.Any())
{
foreach (var vm in virtualMachineModels)
{
if (vm.Name.Equals(name))
{
switch (performanceCounterType)
{
case PerformanceCounterType.CPUUsage:
{
var p = new DynamicParameters();
p.Add("tieredPerfCounterID", vm.CPUTieredPerfCounterID, DbType.Guid, ParameterDirection.Input);
p.Add("aggregationLevel", (int)timeframeType, DbType.Int32, ParameterDirection.Input);
p.Add("error", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
var commandPerfCPU = new DapperCommand
{
Name = "[dbo].[prc_PCMT_PerfHistory_Get]",
Parametrs = p,
Type = CommandType.StoredProcedure
};
var cpuValues = await this.provider.ExecuteAsync <PerfCounterModel>(commandPerfCPU);
values = cpuValues.OrderBy(t => t.Timestamp).ToList();
}
break;
case PerformanceCounterType.NetworkIOUsage:
{
var readParams = new DynamicParameters();
readParams.Add("tieredPerfCounterID", vm.NetworkBytesReadTieredPerfCounterID, DbType.Guid, ParameterDirection.Input);
readParams.Add("aggregationLevel", (int)timeframeType, DbType.Int32, ParameterDirection.Input);
readParams.Add("error", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
var commandPerfReadNet = new DapperCommand
{
Name = "[dbo].[prc_PCMT_PerfHistory_Get]",
Parametrs = readParams,
Type = CommandType.StoredProcedure
};
var readNetValues = await this.provider.ExecuteAsync <PerfCounterModel>(commandPerfReadNet);
var writeParams = new DynamicParameters();
writeParams.Add("tieredPerfCounterID", vm.NetworkBytesWriteTieredPerfCounterID, DbType.Guid, ParameterDirection.Input);
writeParams.Add("aggregationLevel", (int)timeframeType, DbType.Int32, ParameterDirection.Input);
writeParams.Add("error", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
var commandPerfWriteNet = new DapperCommand
{
Name = "[dbo].[prc_PCMT_PerfHistory_Get]",
Parametrs = writeParams,
Type = CommandType.StoredProcedure
};
var writeNetValues = await this.provider.ExecuteAsync <PerfCounterModel>(commandPerfWriteNet);
values = readNetValues.Union(writeNetValues)
//.Select(t => new PerfCounterModel { Value = t.Value / 1000, Timestamp = t.Timestamp })
.OrderBy(t => t.Timestamp)
.ToList();
}
break;
case PerformanceCounterType.StorageIOPSUsage:
{
var readParams = new DynamicParameters();
readParams.Add("tieredPerfCounterID", vm.DiskBytesReadTieredPerfCounterID, DbType.Guid, ParameterDirection.Input);
readParams.Add("aggregationLevel", (int)timeframeType, DbType.Int32, ParameterDirection.Input);
readParams.Add("error", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
var commandPerfReadStorage = new DapperCommand
{
Name = "[dbo].[prc_PCMT_PerfHistory_Get]",
Parametrs = readParams,
Type = CommandType.StoredProcedure
};
var readDiskValues = await this.provider.ExecuteAsync <PerfCounterModel>(commandPerfReadStorage);
var writeParams = new DynamicParameters();
writeParams.Add("tieredPerfCounterID", vm.DiskBytesWriteTieredPerfCounterID, DbType.Guid, ParameterDirection.Input);
writeParams.Add("aggregationLevel", (int)timeframeType, DbType.Int32, ParameterDirection.Input);
writeParams.Add("error", dbType: DbType.Int32, direction: ParameterDirection.ReturnValue);
var commandPerfWriteStorage = new DapperCommand
{
Name = "[dbo].[prc_PCMT_PerfHistory_Get]",
Parametrs = writeParams,
Type = CommandType.StoredProcedure
};
var writeDiskValues = await this.provider.ExecuteAsync <PerfCounterModel>(commandPerfWriteStorage);
values = readDiskValues.Union(writeDiskValues)
//.Select(t => new PerfCounterModel { Value = t.Value / 10000, Timestamp = t.Timestamp })
.OrderBy(t => t.Timestamp)
.ToList();
}
break;
}
break;
}
}
}
return(values);
}
private async void View_RemovePairFromAnalise(PairOfMarket pair, TimeframeType timeframe, int barCount)
{
await ExcludePairToStrategy(pair, timeframe, barCount);
}
public HistoryPriceFeature(PairOfMarket pair, TimeframeType timeframe, DateTime startTime) : this(pair, timeframe)
{
StartTime = startTime;
}
public async Task RunPerformanceAsync(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType, IProgress <Tuple <PerformanceCounterType, PerfCounterModel> > progress)
{
await Task.Run(async() =>
{
var random = new Random();
int prevPoint = 0;
while (true)
{
await Task.Yield();
int point = prevPoint > 0 ? prevPoint : startPoint;
// Update the point price by a random factor of the range percent
int number = (point + (int)(random.NextDouble() * random.Next(0, 30))) - random.Next(0, 50);
if (number < minPoint)
{
number = random.Next(0, 10);
}
else if (number > maxPoint)
{
number = 100;
}
progress.Report(new Tuple <PerformanceCounterType, PerfCounterModel>(performanceCounterType, new PerfCounterModel {
Timestamp = DateTime.Now, Value = number
}));
await Task.Delay(250);
prevPoint = number;
}
}).ConfigureAwait(false);
}
private async void View_AddPairToAnalise(PairOfMarket pair, TimeframeType timeframe, int barCount)
{
await IncludePairToStrategy(pair, timeframe, barCount);
}
public Indicator.MACross MACross(TimeframeType timeframe)
{
return(_indicator.MACross(Input, timeframe));
}
public async Task <IEnumerable <PerfCounterModel> > GetPerformance(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType)
{
var random = new Random();
random.NextDouble();
var numbers = new List <PerfCounterModel>();
for (int i = 0; i < 2; i++)
{
await Task.Yield();
int number = performanceCounterType == PerformanceCounterType.CPUUsage
? random.Next(0, 100) : performanceCounterType == PerformanceCounterType.NetworkIOUsage
? random.Next(0, 5000) : random.Next(0, 1000000);
numbers.Insert(i, new PerfCounterModel
{
Timestamp = DateTime.Now,
Value = number
});
}
return(numbers);
}
public OrdersToBars(TimeframeType timeframe)
{
_timeframe = timeframe;
}
public async Task <int> GetPerformanceMeanValue(string name, PerformanceCounterType performanceCounterType, TimeframeType timeframeType)
{
var random = new Random();
random.NextDouble();
var numbers = new List <int>();
for (int i = 0; i < 100; i++)
{
await Task.Yield();
int number = random.Next(0, 100);
numbers.Insert(i, number);
}
return(numbers.Sum() / numbers.Count);
}
