/// <summary>
/// Constructor.
/// </summary>
public ThreadPoolFastExecutionStrategy(bool useCommonMessageBusPool)
{
_useCommonMessageBusPool = useCommonMessageBusPool;
GeneralHelper.GenericDelegate<Envelope> delegateInstance = new GeneralHelper.GenericDelegate<Envelope>(PerformExecution);
_performExecutionDelegate = FastInvokeHelper.GetMethodInvoker(delegateInstance.Method, true, false);
}
/// <summary>
/// Constructor.
/// </summary>
public ThreadPoolFastExecutionStrategy(bool useCommonMessageBusPool)
{
_useCommonMessageBusPool = useCommonMessageBusPool;
GeneralHelper.GenericDelegate <Envelope> delegateInstance = new GeneralHelper.GenericDelegate <Envelope>(PerformExecution);
_performExecutionDelegate = FastInvokeHelper.GetMethodInvoker(delegateInstance.Method, true, false);
}
/// <summary>
/// Constructor.
/// </summary>
public ThreadPoolFastExecutionStrategy(ArbiterSlimActiveClientStub client, bool useCommonArbiterPool)
: base(client)
{
_useCommonArbiterPool = useCommonArbiterPool;
GeneralHelper.GenericDelegate <ThreadPoolFast, Envelope> delegateInstance = new GeneralHelper.GenericDelegate <ThreadPoolFast, Envelope>(PerformExecution);
_singleFastInvokeDelegate = FastInvokeHelper.GetMethodInvoker(delegateInstance.Method, false);
}
/// <summary>
/// Will attemp to close all slave orders simultaniously.
/// </summary>
/// <returns>True if at least one slave order was closed.</returns>
public bool Close(out string operationResultMessage)
{
int result = 0;
string operationMessageSum = string.Empty;
int ordersToProcess;
lock (this)
{
ordersToProcess = _placedSlaveOrders.Count;
}
ManualResetEvent processEvent = new ManualResetEvent(false);
GeneralHelper.GenericDelegate <ActiveOrder> closeDelegate =
delegate(ActiveOrder order)
{
string innerOperationResultMessage;
bool innerResult = order.Close(out innerOperationResultMessage);
lock (this)
{
ordersToProcess--;
if (innerResult)
{
result++;
_placedSlaveOrders.Remove(order);
operationMessageSum += System.Environment.NewLine + /*"Order [" + order.OrderExecutionProvider..Info.Name + */ "], Result [OK]";
}
else
{
operationMessageSum += System.Environment.NewLine + /*"Order [" + order.OrderExecutionProvider.Info.Name +*/ "], Result [" + innerOperationResultMessage + "]";
}
if (ordersToProcess == 0)
{ // The last one should set the event to notify the main thread.
processEvent.Set();
}
}
};
lock (this)
{
foreach (ActiveOrder order in _placedSlaveOrders)
{// Delegate will remove orders from _openedSlaveOrders, but only after lock is released, so no problem to do it like this.
GeneralHelper.FireAndForget(closeDelegate, order);
}
}
// Wait for all orders placement to end.
processEvent.WaitOne();
lock (this)
{
if (_placedSlaveOrders.Count == 0)
{
State = OrderStateEnum.Closed;
}
}
operationResultMessage = operationMessageSum;
return(result > 0);
}
/// <summary>
/// Updates some parts of the UI, since others must be updated on given events only.
/// </summary>
public void UpdateUI()
{
this.Enabled = ((_selectedSession != null && _selectedSession.OrderExecutionProvider != null) || _sessionManager != null);
if (this.Enabled == false)
{
return;
}
// Update SessionsArray UI combobox
for (int i = 0; i < _sessions.Count + 1; i++)
{
if (toolStripComboBoxAccount.Items.Count <= i)
{
toolStripComboBoxAccount.Items.Add("");
}
if (i == 0)
{// All accountInfos go first.
if ((string)toolStripComboBoxAccount.Items[0] != "All")
{
toolStripComboBoxAccount.Items[0] = "All";
}
}
else
{
string name = GetSessionName(_sessions[i - 1]);
if ((string)toolStripComboBoxAccount.Items[i] != name)
{
toolStripComboBoxAccount.Items[i] = name;
}
}
}
while (_sessions.Count + 1 < toolStripComboBoxAccount.Items.Count)
{
toolStripComboBoxAccount.Items.RemoveAt(toolStripComboBoxAccount.Items.Count - 1);
}
if (toolStripComboBoxAccount.SelectedIndex < 0)
{
toolStripComboBoxAccount.SelectedIndex = 0;
}
// Update
this.listViewOrders.Visible = _compactMode == false;
this.toolStripButtonCloseOrder.Visible = _compactMode == false;
this.toolStripButtonModifyOrder.Visible = _compactMode == false;
toolStripButtonDisplayMode.Visible = _allowCompactMode;
toolStripSeparatorDisplayMode.Visible = _allowCompactMode;
this.toolStripButtonNewOrder.Enabled = _selectedSession != null;
//this.toolStripButtonObtainOrders.Enabled = true;
this.toolStripButtonCloseOrder.Enabled = listViewOrders.SelectedItems.Count > 0;
this.toolStripButtonModifyOrder.Enabled = listViewOrders.SelectedItems.Count > 0;
if (_compactMode)
{
toolStripButtonDisplayMode.Text = "Full Mode";
}
else
{
toolStripButtonDisplayMode.Text = "Compact Mode";
}
if (_alwaysShowAccountSelectionTools)
{
toolStripLabelAccount.Visible = true;
toolStripComboBoxAccount.Visible = true;
toolStripSeparatorAccount.Visible = true;
}
else
{
// If only 1 account to manage, do not show
toolStripLabelAccount.Visible = _sessions.Count > 1;
toolStripComboBoxAccount.Visible = _sessions.Count > 1;
toolStripSeparatorAccount.Visible = _sessions.Count > 1;
}
List <ListViewItem> items = new List <ListViewItem>();
foreach (ListViewItem item in listViewOrders.Items)
{
items.Add(item);
}
foreach (ExpertSession session in _sessions)
{
if (IsSessionVisible(session))
{
lock (session)
{
GeneralHelper.GenericDelegate <Order, AccountInfo> UpdateOrder = delegate(Order order, AccountInfo account)
{
if (IsOrderVisible(order) == false)
{
return;
}
bool orderFound = false;
foreach (ListViewItem item in items)
{
if (item.Tag == order)
{
SetItemAsOrder(item, order, account);
orderFound = true;
items.Remove(item);
break;
}
}
if (orderFound == false)
{
ListViewItem item = new ListViewItem();
listViewOrders.Items.Add(item);
SetItemAsOrder(item, order, account);
}
};
IOrderSink executor = session.OrderExecutionProvider;
ITradeEntityManagement ordersManagement = session.OrderExecutionProvider.TradeEntities;
if (ordersManagement != null && session.OrderExecutionProvider.DefaultAccount != null)
{
lock (ordersManagement)
{
foreach (Order order in ordersManagement.OrdersUnsafe)
{
UpdateOrder(order, session.OrderExecutionProvider.DefaultAccount.Info);
}
}
}
}
}
}
foreach (ListViewItem item in items)
{
listViewOrders.Items.Remove(item);
}
}
static public MethodInfo GetMethodInfo <TParam1, TParam2, TParam3>(GeneralHelper.GenericDelegate <TParam1, TParam2, TParam3> delegateInstance)
{
return(delegateInstance.Method);
}
/// <summary>
/// Redefine needed so that we can construct and pass anonymous delegates with parater.
/// No need to specify the Value parameter(s), since they can be recognized automatically by compiler.
/// </summary>
public static void FireAndForget <ValueType1, ValueType2>(GeneralHelper.GenericDelegate <ValueType1, ValueType2> d, params object[] args)
{
_threadPoolEx.Queue(d, args);
}
