Multiple Close Single Action

PanagiotisCharalampous
31 May 2019, 09:41

Hi Max,

This is not multithreading but event criven programming. Both OnPositionsClosed and OnTick are event which do not depend on each other. My approach would be to trigger the order only when all the positions of the group have closed. However without the cBot code we cannot provide specific guidance as we can only make assumptions about it.

Best Regards,

Panagiotis

GDPR-83_694920
31 May 2019, 10:28

Hi Panagiotis

Ok many thanks for confimring about the event driven programming and that they run independantly/it is not multithreading

Yes that is exactly what I am trying to achieve - trigger the new order only once the last of the group of closing trades has completed through the OnPositionsClosed method

Here is an example code I quickly put together - slightly different from the original question in that I am actually using a CloseAllPositions method to trigger the closing of a group of trades and also obviously this code is not complete but hopefully is enough to give you an idea

        protected override void OnStart()
        {
            Positions.Closed += OnPositionsClosed;
        }
        protected override void OnTick()
        {
            Counter=0;
            if (x=y)
               CloseAllPostions();
        }
        private void CloseAllPositions()
        {
            foreach (Position p in Positions.Where(p => p.Label == BotLabel).ToArray())
                ClosePosition(p);
        }
        private void OnPositionsClosed(PositionClosedEventArgs args)
        {
            Position pos = args.Position;
            if (pos.Label == BotLabel)
            {
                ++Counter;
                if (Counter == 1)
                    ExecuteMarketOrder(TradeType.Buy, Symbol, Volume, BotLabel, null, null);
            }
        }

Obviously this will trigger the new trade when the first of the group of closing trades loops through the OPC method and yes as you say I would much rather do this only when the last of the group of trades has looped through the OPC so another way I tried was to count the number of open positions in the CloseAllPositions method before they were closed and trigger the new order in the OPC method only when the number of orders are zero

        private void CloseAllPositions()
        {
         OpenPositionsCount = Positions.Where(p => p.Label == BotLabel).Count();
         foreach (Position p in Positions.Where(p => p.Label == BotLabel).ToArray())
                ClosePosition(p);
        }
        private void OnPositionsClosed(PositionClosedEventArgs args)
        {
            Position p = args.Position;
            if (p.Label == BotLabel)
            {
             if (OpenPositionsCount==0)
                    ExecuteMarketOrder(TradeType.Buy, Symbol, Volume, BotLabel, null, 5);
            }
        }

It was very quickly clear that this doesn't work though (it was an early attempt at figuring this out but wanted to put it in as one of the alternative ideas) as the number of orders are already zero by the time the first loop of the OPC occurs as they have all been closed already and it is only the event driven programming that is processing these closures through the OPC so 10 new orders are triggered as they loop through the OPC

There are quite a few other ways I tried but all had their own problems and as I say the ++Counter approach seems to work the best but gets messed up if a tick occurs in the time that the group of closing orders are being processed through the OPC

Hope that is what you are after in terms of a better explanation - basically I guess the question is "how is it possible to properly 'detect' that event driven programming processes have properly completed?"

(Although I think that is not really a correct/impossible to answer question but hopefully it makes some sense!)

Many thanks

Max

PanagiotisCharalampous
31 May 2019, 10:47

Hi Max,

I thing I am still missing something since if this was the code you are using then the solution would be as simple as this

private void CloseAllPositions()
{
    foreach (Position p in Positions.Where(p => p.Label == BotLabel).ToArray())
        ClosePosition(p);
    ExecuteMarketOrder(TradeType.Buy, Symbol, Volume, BotLabel, null, 5);
}

However I am sure this is not the case :) and this is just an exampe. From what I understand, the positions are closed by TP so you are not sure when did all the positions close and if there are other Closed events coming. So my suggestion is to keep each position you open in a collection (list, dictionary etc) and remove it from the collection as soon as you receive the Closed event for that position. As soon as the collection is empty (meaning all positions closed successfully) you can proceed with sending the new order.

Let me know if this gives you a direction.

Best Regards,

Panagiotis

GDPR-83_694920
31 May 2019, 11:05

Haha :) yes I knew something like that would happen - there are much easier ways to achieve the same result as I have presented it!

But of course this is not the full code/strategy although I think you have got it there/on the right track with the collection idea

The basic idea behind the strategy is to open two opposing positions each with a TP - when a TP is hit again two opposing positions are to be opened with their own TP's

The TP's are modified as time progresses in a manner that means in some situations multiple Buy positions (for example) would all have the same TP (for example 6 out of the 10 exisiting Buy positions now have the same TP) which will all close at the same time when their TP is hit

When this happens I want to only open one more pair of Buy/Sell order (not 6 pairs!)

So yes I think this could be achieved with the collections idea as you suggest but hmmmmm.... looking at it again/quickly thinking it through perhaps not as it would only be 6 of the 10 orders (in this example) that are closing...

Maybe this further explanation will help you come up with another approach or even if not it would be great if you could give an example of how what you've already said could be achieved - I have no problem creating the collection but how/where would I receive the Closed event and process it properly...?