public VisitorComposerWorker(string ident, StrategyInstance connection)
{
//Discarded unreachable code: IL_0002, IL_0006
//IL_0003: Incompatible stack heights: 0 vs 1
//IL_0007: Incompatible stack heights: 0 vs 1
SingletonReader.PushGlobal();
m_PublisherInstance = -1L;
base._002Ector();
_SetterInstance = ident;
SortDic(connection);
}
/// <summary>
/// Add new strategy instance
/// </summary>
/// <param name="strategyInstance"></param>
public void AddStrategyInstance(StrategyInstance strategyInstance)
{
//create strategy executor instance responsible for entire Strategy Instance life cycle
StrategyExecutor executor = new StrategyExecutor(strategyInstance, _currentDispatcher);
//subscribe to strategy event changed event
executor.StatusChanged += OnStrategyStatusChanged;
executor.ExecutionReceived += OnExecutionReceived;
//map the executor instance in dictionary
_strategiesCollection.TryAdd(strategyInstance.InstanceKey, executor);
}
/// <summary>
/// 卖出操作
/// </summary>
/// <returns></returns>
public bool doSell()
{
showBeginMessage("选择卖出股票...");
try
{
//取得持仓
doGetHolds();
if (holdRecords.Count <= 0)
{
return(true);
}
//创建策略上下文
createStrategyContext();
//取得策略
String strategyname = props.Get <String>("strategy");
KeyValuePair <IStrategyMeta, insp.Utility.Bean.Properties> kv = context.GetStrateMetaAndParam(strategyname);
if (kv.Key == null || kv.Value == null)
{
throw new Exception("缺少有效策略");
}
StrategyInstance instance = (StrategyInstance)kv.Key.CreateInstance("1", kv.Value, "");
//取得卖出算法类
String sellername = kv.Value.Get <String>("seller");
Seller seller = (Seller)instance.Seller;
if (instance.Seller == null)
{
throw new Exception("缺少有效的卖出策略:" + sellername);
}
//对持仓逐个判断是否要卖出
sellEntrust.Clear();
String tradeFilename = FileUtils.GetDirectory("records") + "trades.csv";
foreach (HoldRecord hold in holdRecords)
{
insp.Utility.Bean.Properties sellParams = seller.PDC.CreateProperties(hold.parameters);
TradeInfo tradeInfo = seller.DoSell(hold, this.tradeDate, sellParams, context);
if (tradeInfo == null)
{
continue;
}
File.AppendAllLines(tradeFilename, new string[] { tradeInfo.ToString() });
sellEntrust.Add(tradeInfo);
}
showResultMessage("");
return(true);
}catch (Exception e)
{
showResultMessage("卖出操作异常", -1, e.Message);
return(false);
}
}
public void TestThatStrategyIsExecutingAndChangingItsStatus()
{
string assemblyPath =
Path.GetFullPath(@"~\..\..\..\..\Lib\testing\TradeHub.StrategyEngine.Testing.SimpleStrategy.dll");
Assert.True(File.Exists(assemblyPath));
var classtype = StrategyHelper.GetStrategyClassType(assemblyPath);
var parametersDetails = StrategyHelper.GetParameterDetails(classtype);
Dictionary <string, ParameterDetail> parameters = new Dictionary <string, ParameterDetail>();
parameters.Add("1", new ParameterDetail(typeof(int), 10));
parameters.Add("2", new ParameterDetail(typeof(int), 15));
parameters.Add("3", new ParameterDetail(typeof(string), "LAST"));
parameters.Add("4", new ParameterDetail(typeof(string), "ERX"));
parameters.Add("5", new ParameterDetail(typeof(decimal), 1000));
parameters.Add("6", new ParameterDetail(typeof(string), BarFormat.TIME));
parameters.Add("7", new ParameterDetail(typeof(string), BarPriceType.LAST));
parameters.Add("8", new ParameterDetail(typeof(string), TradeHubConstats.MarketDataProvider.SimulatedExchange));
parameters.Add("9", new ParameterDetail(typeof(string), TradeHubConstats.OrderExecutionProvider.SimulatedExchange));
object[] paramters =
{
(int)10, (int)15, (string)"LAST", (string)"ERX", (decimal)1000, BarFormat.TIME, BarPriceType.LAST,
TradeHubConstats.MarketDataProvider.SimulatedExchange, TradeHubConstats.OrderExecutionProvider.SimulatedExchange
};
var instance = StrategyHelper.CreateStrategyInstance(classtype, paramters);
StrategyInstance strategyInstance = new StrategyInstance();
strategyInstance.InstanceKey = "A00";
strategyInstance.Parameters = parameters;
strategyInstance.StrategyType = classtype;
strategyInstance.Symbol = "ERX";
StrategyController controller = new StrategyController();
StrategyStatusRepresentation statusRepresentationrepresentation = null;
ManualResetEvent resetEvent = new ManualResetEvent(false);
controller.StrategyStatusChanged += delegate(StrategyStatusRepresentation representation)
{
statusRepresentationrepresentation = representation;
resetEvent.Set();
};
controller.AddStrategyInstance(strategyInstance);
resetEvent.WaitOne(5000);
controller.RunStrategy(strategyInstance.InstanceKey);
resetEvent.WaitOne(2000);
Assert.NotNull(statusRepresentationrepresentation);
Assert.AreEqual(StrategyStatus.Executing, statusRepresentationrepresentation.StrategyStatus);
}
/// <summary>
/// Argument Constructor
/// </summary>
/// <param name="strategyInstance">Holds necessary information for Instance Execution and UI-Update</param>
/// <param name="currentDispatcher"></param>
public StrategyExecutor(StrategyInstance strategyInstance, Dispatcher currentDispatcher)
{
this._currentDispatcher = currentDispatcher;
_asyncClassLogger = new AsyncClassLogger("StrategyExecutor");
//set logging path
string path = DirectoryStructure.CLIENT_LOGS_LOCATION;
_asyncClassLogger.SetLoggingLevel();
_asyncClassLogger.LogDirectory(path);
_tradeHubStrategy = null;
_strategyInstance = strategyInstance;
_strategyKey = _strategyInstance.InstanceKey;
_strategyType = _strategyInstance.StrategyType;
_ctorArguments = _strategyInstance.GetParameterValues();
}
/// <summary>
/// 买入操作
/// </summary>
/// <returns></returns>
public bool doBuy()
{
showBeginMessage("选择买入股票...");
try
{
//创建策略上下文
createStrategyContext();
//取得策略
String strategyname = props.Get <String>("strategy");
KeyValuePair <IStrategyMeta, insp.Utility.Bean.Properties> kv = context.GetStrateMetaAndParam(strategyname);
if (kv.Key == null || kv.Value == null)
{
throw new Exception("缺少有效策略");
}
StrategyInstance instance = (StrategyInstance)kv.Key.CreateInstance("1", kv.Value, "");
//取得买入算法类
String buyername = kv.Value.Get <String>("buyer");
Buyer buyer = (Buyer)instance.Buyer;
if (buyer == null)
{
throw new Exception("缺少有效的卖出策略:" + buyername);
}
List <TradeInfo> tradeInfos = buyer.DoBuy(kv.Value, this.tradeDate, context);
if (tradeInfos != null && tradeInfos.Count >= 0)
{
String tradeFilename = FileUtils.GetDirectory("records") + "trades.csv";
buyEntrust.AddRange(tradeInfos);
File.AppendAllLines(tradeFilename, buyEntrust.ConvertAll(x => x.ToText()).ToArray());
}
return(true);
}catch (Exception e)
{
showResultMessage("买入操作异常", -1, e.Message);
return(false);
}
}
protected void SortDic(StrategyInstance setup)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ResolverDic.AddError();
_GetterInstance = (setup ?? new StrategyInstance());
SystemDic systemDic = _0001(_GetterInstance);
_SystemInstance = CallDic(systemDic);
systemDic._0001(-3, readivk: true);
identifierInstance = WriteDic(systemDic);
if (_GetterInstance._0002())
{
workerInstance = systemDic;
}
else
{
Marshal.ReleaseComObject(systemDic);
}
}
protected virtual SystemDic _0001(StrategyInstance setup)
{
//Discarded unreachable code: IL_0002
//IL_0003: Incompatible stack heights: 0 vs 1
ValDic.FlushError(_SetterInstance, null, out SystemDic rule);
rule._0001(-2, readivk: false);
rule._0001(-3, readivk: true);
BaseClassSpec baseClassSpec = new BaseClassSpec();
baseClassSpec._0002(TemplateInstance.m_ConfigInstance);
baseClassSpec._0001(setup._0001() ? IndexerInstance.baseInstance : IndexerInstance._TokenInstance);
BaseClassSpec baseClassSpec2 = PublishDic(rule);
baseClassSpec._0002(baseClassSpec2._0002());
baseClassSpec._0001(baseClassSpec2._0001());
try
{
rule._0001(-3, IntPtr.Zero, baseClassSpec._0001());
}
catch (COMException item) when(item.CompareError() == -1072875852)
{
if (!(baseClassSpec2._0001() == IndexerInstance._DecoratorInstance) || baseClassSpec2._0002() != 1)
{
throw;
}
int reference_low;
baseClassSpec2._0001(reference_low = baseClassSpec2._0001() * 2);
baseClassSpec._0001(reference_low);
baseClassSpec2._0002(reference_low = baseClassSpec2._0002() * 2);
baseClassSpec._0002(reference_low);
rule._0001(-3, IntPtr.Zero, baseClassSpec._0001());
}
Marshal.ReleaseComObject(baseClassSpec2._0001());
return(rule);
}
/// <summary>
/// Start Strategy Optimization
/// </summary>
/// <param name="optimizationParameters">Contains info for the parameters to be used for optimization</param>
private void StartOptimization(BruteForceParameters optimizationParameters)
{
try
{
// Save instance
_optimizationParameters = optimizationParameters;
if (_asyncClassLogger.IsInfoEnabled)
{
_asyncClassLogger.Info("Getting argument combinations", _type.FullName, "StartOptimization");
}
// Change Status to indicate on UI
_optimizationParameters.Status = OptimizationStatus.Working;
// Clear all previous information
_strategiesCollection.Clear();
_ctorArguments.Clear();
// Get Parameter values to be used in the Constructor
object[] ctorArguments = optimizationParameters.GetParameterValues();
// Get Conditional Parameter values to be used for creating Iterations
Tuple <int, object, double>[] conditionalParameters = optimizationParameters.GetConditionalParameters();
// Save Parameter Details
_parmatersDetails = optimizationParameters.ParameterDetails;
// Get all ctor arguments to be used for optimization
CreateCtorCombinations(ctorArguments, conditionalParameters);
// Initialize Stratgey for each set of arguments
foreach (object[] ctorArgumentValues in _ctorArguments)
{
// Get new Key.
string key = ApplicationIdGenerator.NextId();
var instanceParameterDetails = new Dictionary <string, ParameterDetail>();
for (int i = 0; i < ctorArgumentValues.Length; i++)
{
// Create new parameter details to be when creating Strategy Instance object
ParameterDetail tempParameterDetail = new ParameterDetail(_parmatersDetails[i].ParameterType, ctorArgumentValues[i]);
instanceParameterDetails.Add(_parmatersDetails[i].Description, tempParameterDetail);
}
// Create Strategy Instance object
var instance = new StrategyInstance(key, instanceParameterDetails, optimizationParameters.StrategyType);
// Save Strategy details in new Strategy Executor object
var strategyExecutor = new StrategyExecutor(instance, _currentDispatcher);
// Register Event
strategyExecutor.StatusChanged += OnStrategyExecutorStatusChanged;
// Add to local map
_strategiesCollection.AddOrUpdate(key, strategyExecutor, (ky, value) => strategyExecutor);
StringBuilder parametersInfo = new StringBuilder();
foreach (object ctorArgument in strategyExecutor.CtorArguments)
{
parametersInfo.Append(ctorArgument.ToString());
parametersInfo.Append(" | ");
}
// Create new object to be used with Event Aggregator
var optimizationStatistics = new OptimizationStatistics(strategyExecutor.StrategyKey);
optimizationStatistics.Description = parametersInfo.ToString();
optimizationStatistics.ExecutionDetails = instance.ExecutionDetails;
// Raise event to Bind statistics to UI and will be updated as each instance is executed
EventSystem.Publish <OptimizationStatistics>(optimizationStatistics);
}
// Save total number of iterations count
_optimizationParameters.TotalIterations = _strategiesCollection.Count;
// Start executing each instance
StartStrategyExecution();
}
catch (Exception exception)
{
_asyncClassLogger.Error(exception, _type.FullName, "StartOptimization");
}
}
/// <summary>
/// Argument Constructor
/// </summary>
/// <param name="strategyInstance">Contains instance details</param>
public StrategyInstanceSummaryViewModel(StrategyInstance strategyInstance)
{
_strategyInstance = strategyInstance;
}
