修改订单时的错误#1 - 页 4

新评论
 
hoz:

鲍里斯，让我们假设是这样的情况...假设。但是，如果该函数重新发送一个订单来修改订单，则应修改signantton。而对我来说，它根本就没有修改。即使我们看一下日志中的记录，我们看到的也是这样。

为什么要发送订单？如果它没有正确的参数，这个函数就会被炸毁......这就好比是OK.........它被送来了。然后，事实证明，有一个错误...这背后的逻辑是什么？

刚开机!维克多，如果 "ok"，意味着某些参数发生了变化，但错误1意味着某些参数被声明为变化，但结果是没有变化。这就是为什么我们需要纠正你的逻辑，以避免这种情况，所有这些不准确的情况将导致重新报价，并在真正的市场上出现大量的错误!

你知道我不使用这种编程风格，所有的东西都散落在各个地方。我把程序写成一个逻辑脚本，所有的事件都是按顺序发展的，所有的东西都是近在咫尺的，所有的条件都不需要到处去找。而我使用外部函数 来执行最后的动作并检查错误。

但在你的情况下，没有经验的人不清楚你有什么，在哪里检查了，一切都被隐藏起来，你必须猜测你是否检查了先决条件！"。那是很多话，就像我现在的一样，但你的程序并没有表达出重点。它应该是清晰和简明的!

 

鲍里斯，我当然意识到，我没有把所有东西都放在一个地方。但在修改函数之前的输入参数是停靠的。我刚刚扔了一张截图。有当前 和新的 PLO，SL和TP。而且它们都是不同的。既然一切都在附近，我为什么要纠结于细节呢？如果是未打印的，而且你可以看到参数是不同的，这意味着它们确实是不同的。或者说，你也不应该相信印刷品？

2013.08.26 00:00  Kevin Martens_Moi_Myrei EURUSD,M15: PositionsManipulations::fOrderModify: Тикет № 2; New_OOP = 1.34048; New_SL = 1.34125; New_TP = 1.33362
2013.08.26 00:00  Kevin Martens_Moi_Myrei EURUSD,M15: PositionsManipulations::fOrderModify:  Тикет № 2; OrderOpenPrice() = 1.34048; OrderStopLoss() = 0.0; OrderTakeProfit() = 0.0
2013.08.26 00:00  Kevin Martens_Moi_Myrei EURUSD,M15: PositionsManipulations::fOrderModify: Тикет № 2; New_OOP = 1.34048; New_SL = 1.34125; New_TP = 1.33362
2013.08.26 00:00  Kevin Martens_Moi_Myrei EURUSD,M15: PositionsManipulations::fOrderModify: _LastError = 0
2013.08.26 00:00  Kevin Martens_Moi_Myrei EURUSD,M15: modify #2  sell limit 0.10 EURUSD at 1.34048 sl: 1.34125 tp: 1.33362 ok
2013.08.26 00:00  Kevin Martens_Moi_Myrei EURUSD,M15: OrderModify error 1

而在这之前，正如我在上面所展示的，有一个测试。

 if ((ND (OrderOpenPrice()) != fd_OpenPrice) || ND ((OrderStopLoss()) != fd_NewSL) || (ND (OrderTakeProfit()) != fd_NewTP))
{
 ... Если какой-то из параметров отличается от нового, значит выполняется это условие...
}

你怎么能更具体呢？上面有几个小丑开始编造故事。显然，他们不能或不愿理解我的要求。所以他们无缘无故地笑了。但这个问题是一个有趣的问题。

如果我们在OrderModify()中插入其他类型的参数或错误的数量，就会导致错误。在这里，它被执行了，显示为OK，但后来发现没有参数被改变。

问题是我们如何知道那里出了什么问题？我已经布置了我的职能。在那里一切都应该是清楚的。在这里，它是。

// 1.2 Функция модифицирует выделенный ордер (установка TP и SL). =========================================================================
bool PositionsManipulations::fOrderModify (int       fi_Ticket,             // OrderTicket()
                                           double    fd_OpenPrice,          // OpenPrice
                                           double    fd_NewSL,              // Новый StopLoss (УРОВЕНЬ !!!)
                                           double    fd_NewTP,              // Новый TakeProfit (УРОВЕНЬ !!!)
                                           datetime  fdt_Expiration = 0,    // Время истечения отложенного ордера
                                           color     fc_Arrow = CLR_NONE)   // Цвет стрелок модификации StopLoss и/или TakeProfit на графике
{
   Print (__FUNCTION__, ": ", "Вошли в функцию ");

//---- Проверяем необходимость модификации
   if (fd_NewSL == OrderStopLoss() && fd_NewTP == OrderTakeProfit())
       return (false);
//----
   string ls_fName = "fOrderModify()";
   int    li_Cnt = 0;
   double ld_Price;
   bool   lb_InvalidSTOP = false,
          lb_FixInvalidPrice = false;    // Флаг первоначальной коррекции отложки

//---- Получаем актуальную информацию по символу и текущему ордеру
   CBase.GetMarkerInfo (OrderSymbol(), fi_Ticket);
   
   Print (__FUNCTION__, ": ", "До проверки на FREEZELEVEL и STOPLEVEL  тикета № ", fi_Ticket);
   Print (__FUNCTION__, ": ", "Тикет № ", OrderTicket(), "; OrderOpenPrice() = ", OrderOpenPrice(),
             "; OrderStopLoss() = ", OrderStopLoss(), "; OrderTakeProfit() = ", OrderTakeProfit());
   Print (__FUNCTION__, ": ", "Тикет № ", fi_Ticket, "; New_OOP = ", fd_OpenPrice, "; New_SL = ", fd_NewSL, "; New_TP = ", fd_NewTP);
//---- Проверяем на условия FREEZELEVEL и STOPLEVEL
   if (!CheckLevelsBLOCK (3, SPos.gs_Symbol, SPos.gi_Type, fd_OpenPrice, fd_NewSL, fd_NewTP, lb_FixInvalidPrice))
   {
      if (StringLen (CErrs.ErrInf) > 0)      // Если переменная для хранения ошибок не пустая..
      {
         CLogs.WriteLog (CErrs.ErrInf);      //.. то, запишем в лог и выйдем из функции
         return (false);
      }
   }
   Print (__FUNCTION__, ": ", "После проверки на FREEZELEVEL и STOPLEVEL  тикета № ", fi_Ticket);
   Print (__FUNCTION__, ": ", "Тикет № ", fi_Ticket, "; New_OOP = ", fd_OpenPrice, "; New_SL = ", fd_NewSL, "; New_TP = ", fd_NewTP);
   
   ResetLastError();
   
//---- Определяем цвет значков модификации ордеров
   if (fc_Arrow == CLR_NONE)
       fc_Arrow = ColorByModify [OrderType() % 2];
   
//---- Выполняем модификацию в тестере
   if (!CBase.GetRealTrade())
   {
      if ((ND (OrderOpenPrice()) != fd_OpenPrice) || ND ((OrderStopLoss()) != fd_NewSL) || (ND (OrderTakeProfit()) != fd_NewTP))
      {
      ResetLastError();
      
      Print (__FUNCTION__, ": ", " Тикет № ", OrderTicket(), "; OrderOpenPrice() = ", OrderOpenPrice(),
             "; OrderStopLoss() = ", OrderStopLoss(), "; OrderTakeProfit() = ", OrderTakeProfit());
      Print (__FUNCTION__, ": ", "Тикет № ", fi_Ticket, "; New_OOP = ", fd_OpenPrice, "; New_SL = ", fd_NewSL, "; New_TP = ", fd_NewTP);
      Print (__FUNCTION__, ": ", "_LastError = ", _LastError);
      
      if (!OrderModify (fi_Ticket, fd_OpenPrice, fd_NewSL, fd_NewTP, fdt_Expiration, fc_Arrow))
      {
         CLogs.WriteLog (StringConcatenate ("fOrderModify(): ", CErrs.ErrorToString (_LastError)));
         Print (__FUNCTION__, ": ", "После модификации тикета № ", fi_Ticket);
         Print (__FUNCTION__, ": ", "Тикет № ", fi_Ticket, "; New_OOP = ", fd_OpenPrice, "; New_SL = ", fd_NewSL, "; New_TP = ", fd_NewTP);
         return (false);
      }
      }
   }
  

我特意注释了所有的线条。你可能只是破坏了代码。如果你有任何意见，请帮忙。

 
hoz:

鲍里斯，我当然意识到，我没有把所有东西都放在一个地方。但在修改函数之前的输入参数是停靠的。我刚刚扔了一张截图。有当前 和新的 PLO，SL和TP。而且它们都是不同的。既然一切都在附近，我为什么要纠结于细节呢？如果是未打印的，而且你可以看到参数是不同的，这意味着它们确实是不同的。或者说，你也不应该相信印刷品？

而在这之前，正如我上面所展示的，有一个测试。


一切

对不起，我无法理解这一点，因为我没有看到循环中的任何条件，以确保订单参数不会相互混淆！我不知道该怎么办。

错误的出现告诉你，你在某个地方犯了一个逻辑错误。但它也说，该方案是有效的，但我们感兴趣的是方案的质量!

 
borilunad:

对不起，我无法弄清楚这个问题，因为我没有看到循环中的任何条件，以确保订单参数不会相互混淆！我不知道。

错误的出现告诉你，你在某个地方犯了一个逻辑错误。但它也说，该方案是有效的，但我们感兴趣的是方案的质量!


所有与订单有关的操作都是在一个循环中进行的!这就是调用fOrderModify()方法的地方，我在上面引用了其中的代码。

//+---------------------------------------------------------------------------------------------------------------------------------------+
//|                                                   Перенос лимитных ордеров по сигналу                                                 |
//+---------------------------------------------------------------------------------------------------------------------------------------+
void MovingLimitPositions (const double& fd_MurreyLevelsValue[])
{
   double New_OOP = 0.0,
          New_SL = 0.0,
          New_TP = 0.0;
   int    Ticket = -1;
   
   for (int i=0; i<13; i++)
   {
      Print (__FUNCTION__, ": ", "fd_MurreyLevelsValue["+IToS (i)+"] = ", DToS (fd_MurreyLevelsValue[i]));
   }

   for (int i=OrdersTotal()-1; i>=0; i--)
   {
      New_OOP = 0.0;
      New_SL = 0.0;
      New_TP = 0.0;
      
      ResetLastError();
      
      if (!CPosMan.CheckMyOrdersBased(i, 7)) continue;
      if (!OrderSelect (i, SELECT_BY_POS, MODE_TRADES)) continue;

      Ticket = OrderTicket();

      Print (__FUNCTION__, ": ", "Выбран тикет № ", OrderTicket());
      Print (__FUNCTION__, ": ", "Тикет № ", OrderTicket(), "; OrderOpenPrice() = ", OrderOpenPrice(),
             "; OrderStopLoss() = ", OrderStopLoss(), "; OrderTakeProfit() = ", OrderTakeProfit());
          
      if (OrderType() == OP_BUYLIMIT)
      {
         if (ND (OrderOpenPrice()) != ND (fd_MurreyLevelsValue[1]))
            New_OOP = ND (fd_MurreyLevelsValue[1]);
         else New_OOP = ND (OrderOpenPrice());
         if (ND (OrderStopLoss()) != ND (fd_MurreyLevelsValue[0]))
            New_SL = ND (fd_MurreyLevelsValue[0]);
         else New_SL = ND (OrderStopLoss());
         if (ND (OrderTakeProfit()) != ND (fd_MurreyLevelsValue[10]))
            New_TP = ND (fd_MurreyLevelsValue[10]);
         else New_TP = ND (OrderTakeProfit());
         
         Print (__FUNCTION__, ": ", "New_OOP = ", New_OOP, "; New_SL = ", New_SL, "; New_TP = ", New_TP);
         
         if (ND (OrderOpenPrice()) != fd_MurreyLevelsValue[1])
         {
            if (!CPosMan.fOrderModify (OrderTicket(), New_OOP, New_SL, New_TP))
            {
               if (_LastError > 0)
                  CLogs.WriteLog (StringConcatenate (__FUNCTION__, ". В строке ", __LINE__, " ", CErrs.ErrorToString (_LastError)),
                                  CLogs.GetNeedLogs(), CLogs.GetPrintUP(), CLogs.GetCommentUP());
            }
            else
            {Print (__FUNCTION__, ": ", "Модификация тикета №", OrderTicket(), " успешно завершена!");}
         }
      }
      
      if (OrderType() == OP_SELLLIMIT)
      {
         if (ND (OrderOpenPrice()) != ND (fd_MurreyLevelsValue[11]))
            New_OOP = ND (fd_MurreyLevelsValue[11]);
         else New_OOP = ND (OrderOpenPrice());
         if (ND (OrderStopLoss()) != ND (fd_MurreyLevelsValue[12]))
            New_SL = ND (fd_MurreyLevelsValue[12]);
         else New_SL = ND (OrderStopLoss());
         if (ND (OrderTakeProfit()) != ND (fd_MurreyLevelsValue[2]))
            New_TP = ND (fd_MurreyLevelsValue[2]);
         else New_TP = ND (OrderTakeProfit());
         
         Print (__FUNCTION__, ": ", "New_OOP = ", New_OOP, "; New_SL = ", New_SL, "; New_TP = ", New_TP);
         Print (__FUNCTION__, ": ", "Тикет № ", OrderTicket(), "; OrderOpenPrice() = ", OrderOpenPrice(),
             "; OrderStopLoss() = ", OrderStopLoss(), "; OrderTakeProfit() = ", OrderTakeProfit());
             
         if (ND (OrderOpenPrice()) != fd_MurreyLevelsValue[11])
         {
            if (!CPosMan.fOrderModify (Ticket,  New_OOP, New_SL, New_TP))
            {
               if (_LastError != 0)
                  CLogs.WriteLog (StringConcatenate (__FUNCTION__, ". В строке ", __LINE__, " ", CErrs.ErrorToString (_LastError)),
                                  CLogs.GetNeedLogs(), CLogs.GetPrintUP(), CLogs.GetCommentUP());
            }
            else
            {
               Print (__FUNCTION__, ": ", "Модификация тикета №", OrderTicket(), " успешно завершена!");
               Print (__FUNCTION__, ": ", "Тикет № ", OrderTicket(), "; OrderOpenPrice() = ", OrderOpenPrice(),
             "; OrderStopLoss() = ", OrderStopLoss(), "; OrderTakeProfit() = ", OrderTakeProfit());
            }
         }
      }
   }
   Print (__FUNCTION__, ": ", "OUT OF FUNCTION");
}

你可以看到那里的一切...你还可以看到，在循环的每一次迭代之后，错误 都被清除了。因此，事实是保证了前一个订单的错误，如果有的话，不会跳到下一个订单（当然，我是指它的价值）。

还能有多容易呢？它是如此简单...

 

我发现了一条信息。

这是同一个终端错误。我以前从未遇到过这样的错误。我以前从未尝试过改变挂单的三个参数（OOP、SL和TP）。但我不得不这样做。而且我偶然发现了一个错误。

我看到，如果，比如说，开盘价和止损没有变化，取而代之的是我们得到了相同的数值，但取点却发生了变化。它是否也会导致错误？然后发现文件是歪的。而这一点是不被支持的还是什么？

 
hoz:

我发现了一条信息。

这是同一个终端错误。我以前从未遇到过这样的错误。我以前从未尝试过改变挂单的三个参数（OOP、SL和TP）。但我不得不这样做。而且我偶然发现了一个错误。

我看到，如果，比如说，开盘价和止损没有变化，取而代之的是我们得到了相同的数值，但取点却发生了变化。它是否也会导致错误？然后发现文件是歪的。而这一点是不被支持的还是什么？

你也在每次打勾时检查距离吗？我很早以前就采用了这样的规则：在TF栏开盘时开仓，并在M1栏开盘时才修改和关闭订单。上面的代码让我想起了一份进度报告，它似乎包含了所有的内容，但却没有什么具体的内容！我想，这就是我的工作。我没有看到一个循环，在这个循环中，你通过特定的条件来定义所有的行动!我只看到一个循环，告诉我没有什么可以修改的，那么就不要修改，就不会有错误。

注意Renat的重要观点，你的错误可能来自于全局做什么和局部做什么的混乱，而错误总是后者，前面的错误是在你没有参与函数退出的情况下被重置的!

 
borilunad:

你也在每次打钩时检查距离吗？

不！我只允许在满足条件的情况下进行修改。在这种情况下，修改的条件是要改变计算的水平。就像这样。

void OnTick()
{
   static double FirstInd = 0.0;                    // Переменная, которая хранит значение 1-ого индекса массива
   double MurreyLevelsValue[13];                    // Массив значений уровней
   GetDataFromIndicator (MurreyLevelsValue);        // Функция, которая получает значения из индикатора уровней
   
   if (gdt_LastBarTime <= Time[0])
   {
      OTotal = CPosInf.FindPositions (AmountPosByType);   // Получаем количество позиций( по типам ).
      
      GetTradeSignal (MurreyLevelsValue);
      
      gdt_LastBarTime = Time[0];
   }

   if (FirstInd != ND (MurreyLevelsValue[1]))      // Если значений текущего состояния переменной FirstInd не равно новому рассчитанном, то.. 

   {
      MovingLimitPositions (MurreyLevelsValue);     // ..модифицируем ордер новым значением
      FirstInd = ND (MurreyLevelsValue[1]);
   }
}

简单吗？Just....

Borilunad。


我很久以前就制定了一个规则，在TF中开盘时下单，而在M1中开盘时才修改和关闭！这就是我的规则。上面的代码让我想起了一份进度报告，它似乎包含了所有的内容，但却没有什么具体的内容！我想，这就是我的工作。我没有看到一个循环，在这个循环中，你通过特定的条件来定义所有的行动!我只看到一个循环，告诉我没有什么可以修改的，那么就不要修改，就不会有错误。

我也有类似的想法，只在M1开盘时修改，而且，如果是按预定值修改，这也适用。但在有些情况下，我不需要在M1上检查这些数据。例如，我在一个已经计算好的水平上拉了一个止损。然后，正如我上面所展示的，我在OnInit()函数中进行了检查。

if (FirstInd != ND (MurreyLevelsValue[1]))
{
   MovingLimitPositions (MurreyLevelsValue);
   FirstInd = ND (MurreyLevelsValue[1]);
}
也就是说，如果水平发生了变化，它...修改了。这就避免了不必要的修改尝试。因此，可以说是通过信号而不是通过定时器进行修改。这里明白了吗？


borilunad。


我没有看到一个循环，在那里你通过具体条件定义所有的行动！我不知道。我只看到一个循环，告诉我没有什么可修改的，然后就是不修改，没有错误。

我已经在外面把衣服都脱了。有什么不明白的呢...:(

borilunad。

注意Renat的重要观点，你的错误可能来自于全局做什么和局部做什么的混乱，而错误总是后者，前面的错误是在你没有参与函数退出的情况下被重置的!

我不是唯一有这个问题的人，因为我发现。这里有一个例子...

而且看来这个问题没有得到解决，也不会得到解决。也许开发者是懒惰的？如果我的工作没有正确的错误，有人，包括Renat可以探究一下代码，而不是直接说我有错误。

毕竟，如果要修改的参数的新值和当前值在修改功能之前被打印出来，那么很明显这些值就在那里。为什么要去更高的地方？有值，你可以看到没有错误（我在那里打印了错误）。这意味着在逻辑上一切都很好。所以故障在修改功能。

 
hoz:

不！我只允许在满足条件的情况下进行修改。在这种情况下，修改的条件是要改变计算的水平。就像这样。

简单吗？Just....

我也有类似的想法，只在M1开盘时修改，而且，如果修改是按预定值进行的，这也适用。但在有些情况下，我不需要在M1检查这些数据。例如，我在一个已经计算好的水平上拉了一个止损。然后，正如我上面所显示的，在OnInit()函数中有一个检查。

也就是说，如果水平发生了变化，它...修改了。这就避免了不必要的修改尝试。因此，可以说是通过信号而不是通过定时器进行修改。这里明白了吗？


我已经解开了那里的一切。有什么不明白的呢...:(

我发现，这个问题不仅发生在我身上。这里有一个例子...

而且看来这个问题还没有得到解决，也不会得到解决。也许开发者是懒惰的？如果我的工作不正确有错误，有人，包括Renat可以戳到代码，而不是只说我有错误。

毕竟，如果要修改的参数的新值和当前值在修改功能之前被打印出来，那么很明显这些值就在那里。为什么要去更高的地方？有价值，很明显没有错误（我在那里打印了错误）。这意味着在逻辑上一切都很好。因此，错误在于修改功能。

我已经看了这个例子。但我们必须适用于任何条件，直到没有更好的条件。你的代码并不能说服我。我现在要去吃午饭了，然后我给你举个例子，这个循环在设置SL、翻译到B/S和拖拽修改函数的时候都很好用，其中错误的处理，如果在工作中突然出现，在测试器中就不会出现。

你想使用Modify()函数吗？

 
hoz:

毕竟，如果要修改的参数的新值和当前值在修改函数之前被打印出来，那么这些值显然是存在的。为什么要去更高的地方？有价值，很明显没有错误（我在那里打印了错误）。这意味着在逻辑上一切都很好。所以故障在修改功能。

代码看起来很好......而且在真实的（不是演示）上可以工作？
 

维克多，你为什么要修改挂牌头寸中的SL和TP？一般来说，只有在开仓后 才设置SL，而TP则是在SL转移到B/S后才设置！这是有意义的。那么，为什么要白白麻烦服务器，为什么要费这么大的劲呢！？

你需要最大限度地减少和简化代码，使其快速而清晰地工作，然后会因为市场的变化无常而更容易进行调整仔细思考与市场现实有关的所有细微差别!

1234567
新评论