EA代码2（SL经理）的问题

新评论

Funky 2011.09.26 01:53

你好。

再次感谢您在我学习MQL时给予的帮助。

这是我的下一个问题.... 我已经非常接近这个问题了....我让它做了我想做的一切......。但是，如果差距超过这个标准，它就会在每一个交易日修改SLs，而不是只执行一次......

这是一个非常简单的代码，也是一个非常简单的问题，我在这个阶段无法解决，任何帮助将有助于我的学习。

目前这只是买入方面，但是我已经为以后的OP_SELL方面的IFGAP写好了预留。

这个EA的功能是。

1.如果不存在买入交易，则启动一个买入交易。

2. 在TP级别1，将SL向上移动....，在TP级别2，将SL再次向上移动....，在TP级别3，将SL再次向上移动。很好，很简单，真的。

我遇到的新手问题是。

1.如果超过GAP，它就会执行我的OrderModify EVERYTICK...。我想不出如何改变逻辑，但一旦我被告知，我就会知道未来......

提前感谢。

敬请关注，并祝愿大家都能获得快乐的点数。

int start()
{
    if (Bars < 10)
    {
        Comment("Not enough bars");
        return (0);
    }
    if (Terminated == true)
    {
        Comment("EA Terminated.");
        return (0);
    }
    
    OnEveryTick();
    
}

void OnEveryTick()
{
    if (DetectBrokerDigits == false && FiveDigitBroker) PipValue = 10;
    if (DetectBrokerDigits && (NDigits == 3 || NDigits == 5)) PipValue = 10;
    
    IfGap_Level_1();
    IfGap_Level_2();
    IfGap_Level_3();
    IfBUYOrderDoesNotExist();
    
}

void IfGap_Level_1()
{
    for (int i=OrdersTotal()-1; i >= 0; i--)
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
    {
        if (OrderSymbol() == Symbol() && OrderMagicNumber() == BUY_Magic)
        {
            if ((Gap_Level_1 < 0 && ((OrderType() == OP_BUY && Ask - OrderOpenPrice() < Gap_Level_1*PipValue*Point) ||
            (OrderType() == OP_SELL && OrderOpenPrice() - Bid < Gap_Level_1*PipValue*Point))) ||
            ((Gap_Level_1 > 0 && ((OrderType() == OP_BUY && Ask - OrderOpenPrice() > Gap_Level_1*PipValue*Point) ||
            (OrderType() == OP_SELL && OrderOpenPrice() - Bid > Gap_Level_1*PipValue*Point)))))
            {
                BuyOrderModifyLevel_1();
                
            }
        }
    }
    else
    Print("OrderSelect() error - ", ErrorDescription(GetLastError()));
    
}

void BuyOrderModifyLevel_1()
{
    for (int i=OrdersTotal()-1; i >= 0; i--)
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
    {
        if (OrderType() == OP_BUY && OrderSymbol() == Symbol() && OrderMagicNumber() == BUY_Magic)
        {
            double price = Ask;
            if (UseAskLineorNot == false)
            {
                price = OrderOpenPrice();
            }
            bool ret = OrderModify(OrderTicket(), OrderOpenPrice(), price - BuyStoploss_Level_1*PipValue*Point, price + BuyTakeprofit_Level_1*PipValue*Point, 0, Modify_Order_Colour);
            if (ret == false)
            Print("OrderModify() error - ", ErrorDescription(GetLastError()));
        }
    }
    
}

void IfGap_Level_2()
{
    for (int i=OrdersTotal()-1; i >= 0; i--)
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
    {
        if (OrderSymbol() == Symbol() && OrderMagicNumber() == 1)
        {
            if ((Gap_Level_2 < 0 && ((OrderType() == OP_BUY && Ask - OrderOpenPrice() < Gap_Level_2*PipValue*Point) ||
            (OrderType() == OP_SELL && OrderOpenPrice() - Bid < Gap_Level_2*PipValue*Point))) ||
            ((Gap_Level_2 > 0 && ((OrderType() == OP_BUY && Ask - OrderOpenPrice() > Gap_Level_2*PipValue*Point) ||
            (OrderType() == OP_SELL && OrderOpenPrice() - Bid > Gap_Level_2*PipValue*Point)))))
            {
                BuyOrderModifyLevel_2();
                
            }
        }
    }
    else
    Print("OrderSelect() error - ", ErrorDescription(GetLastError()));
    
}

void BuyOrderModifyLevel_2()
{
    for (int i=OrdersTotal()-1; i >= 0; i--)
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
    {
        if (OrderType() == OP_BUY && OrderSymbol() == Symbol() && OrderMagicNumber() == 1)
        {
            double price = Ask;
            if (true == false)
            {
                price = OrderOpenPrice();
            }
            bool ret = OrderModify(OrderTicket(), OrderOpenPrice(), price - BuyStoploss_Level_2*PipValue*Point, price + BuyTakeprofit_Level_2*PipValue*Point, 0, White);
            if (ret == false)
            Print("OrderModify() error - ", ErrorDescription(GetLastError()));
        }
    }
    
}

void IfGap_Level_3()
{
    for (int i=OrdersTotal()-1; i >= 0; i--)
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
    {
        if (OrderSymbol() == Symbol() && OrderMagicNumber() == 1)
        {
            if ((Gap_Level_3 < 0 && ((OrderType() == OP_BUY && Ask - OrderOpenPrice() < Gap_Level_3*PipValue*Point) ||
            (OrderType() == OP_SELL && OrderOpenPrice() - Bid < Gap_Level_3*PipValue*Point))) ||
            ((Gap_Level_3 > 0 && ((OrderType() == OP_BUY && Ask - OrderOpenPrice() > Gap_Level_3*PipValue*Point) ||
            (OrderType() == OP_SELL && OrderOpenPrice() - Bid > Gap_Level_3*PipValue*Point)))))
            {
                BuyOrderModifyLevel_3();
                
            }
        }
    }
    else
    Print("OrderSelect() error - ", ErrorDescription(GetLastError()));
    
}

void BuyOrderModifyLevel_3()
{
    for (int i=OrdersTotal()-1; i >= 0; i--)
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
    {
        if (OrderType() == OP_BUY && OrderSymbol() == Symbol() && OrderMagicNumber() == 1)
        {
            double price = Ask;
            if (true == false)
            {
                price = OrderOpenPrice();
            }
            bool ret = OrderModify(OrderTicket(), OrderOpenPrice(), price - BuyStoploss_Level_3*PipValue*Point, price + BuyTakeprofit_Level_3*PipValue*Point, 0, White);
            if (ret == false)
            Print("OrderModify() error - ", ErrorDescription(GetLastError()));
        }
    }
    
}

void IfBUYOrderDoesNotExist()
{
    bool exists = false;
    for (int i=OrdersTotal()-1; i >= 0; i--)
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
    {
        if (OrderType() == InitialOrderType && OrderSymbol() == Symbol() && OrderMagicNumber() == BUY_Magic)
        {
            exists = true;
        }
    }
    else
    {
        Print("OrderSelect() error - ", ErrorDescription(GetLastError()));
    }
    
    if (exists == false)
    {
        Initial_BuyOrder();
        
    }
}

void Initial_BuyOrder()
{
    double SL = Ask - InitialBuyStoploss*PipValue*Point;
    if (BuyStoploss_Level_3 == 0) SL = 0;
    double TP = Ask + Initial_Takeprofit*PipValue*Point;
    if (Initial_Takeprofit == 0) TP = 0;
    int ticket = -1;
    if (true)
    ticket = OrderSend(Symbol(), OP_BUY, InitialBuyLots, Ask, 4, 0, 0, "My Expert", BUY_Magic, 0, Blue);
    else
    ticket = OrderSend(Symbol(), OP_BUY, InitialBuyLots, Ask, 4, SL, TP, "My Expert", BUY_Magic, 0, Blue);
    if (ticket > -1)
    {
        if (true)
        {
            OrderSelect(ticket, SELECT_BY_TICKET);
            bool ret = OrderModify(OrderTicket(), OrderOpenPrice(), SL, TP, 0, Blue);
            if (ret == false)
            Print("OrderModify() error - ", ErrorDescription(GetLastError()));
        }
            
    }
    else
    {
        Print("OrderSend() error - ", ErrorDescription(GetLastError()));
    }
}



int deinit()
{
    if (ClearAllObjects) ObjectsDeleteAll();
    
    
}

Simon Gniadkowski 2011.09.26 07:54 #1

Funky:

我所遇到的新手问题是

1.如果超过GAP，它就会执行我的OrderModify EVERYTICK...。我想不出如何改变逻辑，但一旦我被告知，我就会知道未来。

如果你不想在每个交易日都执行它，你想什么时候执行它？你是说每个交易日只执行一次吗？

还有一个评论 .. .IfGap_Level_1() 在所有未平仓的订单中循环寻找那些与Symbol和Magic number相匹配的订单，然后检查订单是否有一定的利润，等等 ... ...如果有，它就会调用BuyOrderModifyLevel_1()，这个函数在所有未平仓的订单中循环寻找那些与Symbol和Magic number相匹配 的订单，并且是一个Buy ...看到这里有点重复了吗？为什么你不直接把IfGap_Level_1() 的票号转给BuyOrderModifyLevel_1()？

blackmore 2011.09.26 10:48 #2

Funky:

你好。

再次感谢您在我学习MQL时给予的帮助。

这是我的下一个问题....我已经非常接近这个问题了....我让它做了我想做的一切......。但是，如果差距超过这个标准，它就会在每一个交易日修改SLs，而不是只执行一次......

这是一个非常简单的代码，也是一个非常简单的问题，我在这个阶段无法解决，任何帮助将有助于我的学习。

目前这只是买入方面，但是我已经为以后的OP_SELL方面的IFGAP写好了预留。

这个EA的功能是。

1.如果不存在买入交易，则启动一个买入交易。

2. 在TP级别1，将SL向上移动....，在TP级别2，将SL再次向上移动....，在TP级别3，将SL再次向上移动。真的很好，很简单。

我遇到的新手问题是。

1.如果超过GAP，它就会执行我的OrderModify EVERYTICK...。我想不出如何改变逻辑，但一旦我被告知，我将知道未来......

谢谢你。

衷心感谢您，并祝愿大家都能获得快乐。

你不是一个新手。从优雅的能力来判断，能够写出然后调用函数，你的方式。你应该能够自己看到，你的函数调用（逻辑深度等）也许可以简化为1-2个函数。

而不是。

OrderOpenPrice()

在你的条件中：

if ((Gap_Level_1 < 0 && ((OrderType() == OP_BUY && Ask - OrderOpenPrice() < Gap_Level_1*PipValue*Point) ||

你是否考虑/尝试使用OrderStopLoss()？

Funky 2011.09.26 14:14 #3

RaptorUK:

如果你不想在每个交易日执行，你想什么时候执行？你是说每个交易日只执行一次吗？

还有一个评论 .. .IfGap_Level_1() 在所有未平仓的订单中循环寻找那些与Symbol和Magic number相匹配的订单，然后检查订单是否有一定的利润，等等 ... ...如果是，它就调用BuyOrderModifyLevel_1()，这个函数在所有未平仓的订单中循环寻找那些与Symbol和Magic number相匹配 并且是Buy的订单 ...看到这里有点重复了吗？为什么你不直接把IfGap_Level_1() 的票号转交给BuyOrderModifyLevel_1()？

你好，猛禽，再次感谢你的时间。我的说法，听起来确实令人困惑。我想，我在把所有这些组件正确地连接在一起时遇到了困难。目前，我遇到的主要问题是 "它在每一次打勾时都在修改订单"，但在你的评论之后，我现在也看到了一些其他问题。你说的最后一部分，如果我理解你的意思，你的意思是在检查是否达到缺口后，在IfGap_Level_1的{}中插入BuyOrderModify代码，而不是在它自己的{}中？就像下面这个例子一样？

void OverGap1_soModify()
{
    for (int i=OrdersTotal()-1; i >= 0; i--)
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
    {
        if (OrderSymbol() == Symbol() && OrderMagicNumber() == BUY_Magic)
        {
            if ((Gap_Level_1 < 0 && ((OrderType() == OP_BUY && Ask - OrderOpenPrice() < Gap_Level_1*PipValue*Point) ||
            (OrderType() == OP_SELL && OrderOpenPrice() - Bid < Gap_Level_1*PipValue*Point))) ||
            ((Gap_Level_1 > 0 && ((OrderType() == OP_BUY && Ask - OrderOpenPrice() > Gap_Level_1*PipValue*Point) ||
            (OrderType() == OP_SELL && OrderOpenPrice() - Bid > Gap_Level_1*PipValue*Point)))))
               {
                double price = Ask;
                if (UseAskLineorNot == false)
                {
                 price = OrderOpenPrice();
                 }
            bool ret = OrderModify(OrderTicket(), OrderOpenPrice(), price - BuyStoploss_Level_1*PipValue*Point, price + BuyTakeprofit_Level_1*PipValue*Point, 0, Modify_Order_Colour);
            if (ret == false)
            Print("OrderModify() error - ", ErrorDescription(GetLastError()));
                
            }
        }
    }
    else
    Print("OrderSelect() error - ", ErrorDescription(GetLastError()));
    
}

你知道，我觉得我的另一个EA在某种程度上是脱胎换骨的，现在这个盒子正在形成（这里https://forum.mql4.com/42870 - 非故意的相似性，因为它是一个不同的EA，有不同的目的，然而这也指向了我需要学习的相同领域，比如把两个函数放在一起，我保证我不是想用冗余来填补论坛）。

因此，我可以问一下，如果在同一个地方设置变量 IFNEWORDEREXIST = TRUE，是否可以解决另一个问题。我想让ModeTrades中的最后一笔开仓交易成为我与IfGap_Level_X一直比较的对象（我想这部分与我的其他部分类似）。

一旦我解决了OrderModify在EVERYTICK上发生的错误，而它卡在{}里面，如果上面的方框不正确的话，并处理了最新订单选择问题，我将面临下一个问题：当IfGap_Level_3被满足时，IfGap_Level_2和IfGap_Level_1也被满足。

我有点想让EA充当SL经理，（尽管最初的单一买单）我打算用它来管理多个交易。第一次买入只是为了让我能够回测它。我希望这段代码能够

如果订单的点数达到IfGap_Level_1，我希望它进入BuyOrderModifyLevel_1，然后修改现有订单，并忘记这部分代码。

IfOrder's Pips gets to IfGap_Level_2, I want it to go to BuyOrderModifyLevel_2, then modify existing orders, and forget this part of the code.

如果订单的点数达到IfGap_Level_3，我希望它进入BuyOrderModifyLevel_3，然后修改现有订单，并忘记这部分代码。

我希望我没有说得太远，起初感觉很简单。

我希望我可以在每个区块的末尾插入一个 "break; "或其他的东西，这样就可以摆脱这段代码了......。

diostar。

你不是一个NOOB。从优雅的能力来判断，能够写出然后调用函数，你的方式。你应该能够自己看到，你的函数调用（逻辑深度等）也许可以简化为1-2个函数。

而不是。

在你的条件下。

你是否考虑/尝试使用OrderStopLoss()？

啊，谢谢你，Diostar，你的评论太客气了。我在写基本脚本方面还可以，但是我离这个水平不远了，现在把它连在一起让我很头疼。谢谢你的鼓励，论坛和其他东西对我来说都是有意义的，但对程序的语法/句法就不太了解了。

我相信你所说的可能是正确的，通过将代码浓缩为1-2个函数，我只是不确定如何......

如果我有经验的话，我会把IFGAP和MODIFY ORDER放在一个块中，我想你和Raptor都在建议，然而我在这个阶段是为了安全。我想如果我是一个专家，我会把TP放在一个数组或开关上，并设置old TP=old TP+TPincrement_Level，并且可以在一个块中用大约10行代码完成所有这些工作。最终，我将在最后的If Gap & ModifyOrder {}中做到这一点，这样SL的增量就会以可编程的时间间隔递增，然而，我想根据市场情况，将前几项留待手动设置。

我还没有考虑在公式中使用OrderStopLoss()。我想，由于我将在最初的几个动作中改变一下止损点，我真的希望它基于订单开盘价和它在开盘后增加的点数。我没有很好地解释这个EA，抱歉。谢谢你的时间，伙计，非常感谢。

Problem with EA code 轻松快捷开发 MetaTrader 程序的函数库(第二十五部分)：处理交易服务器返回的错误轻松快捷开发 MetaTrader 程序的函数库 (第

Simon Gniadkowski 2011.09.26 14:31 #4

Funky:

你好，猛龙，再次感谢你的时间。我的说法，听起来确实令人困惑。我想，我在将所有这些组件正确地连接在一起时遇到了困难。目前，我遇到的主要问题是 "它在每一次打勾时都在修改订单"，但在你的评论之后，我现在也看到了一些其他问题。你说的最后一部分，如果我理解你的意思，你的意思是在检查是否达到缺口后，在IfGap_Level_1的{}内插入BuyOrderModify代码，而不是在自己的{}内？就像下面这个例子？

你可以这样做，但这并不是我真正的意思 . . .

请看一下这个，看看它是否有意义 . .

          (OrderType() == OP_SELL && OrderOpenPrice() - Bid > Gap_Level_1*PipValue*Point)))))
            {
                BuyOrderModifyLevel_1(OrderTicket() );    //  <-----  pass the ticket number to the function
                
            }
.
.
.


void BuyOrderModifyLevel_1(int Ticket)
{
    if (OrderSelect(Ticket, SELECT_BY_TICKET, MODE_TRADES))
    {
       double price = Ask;
       if (UseAskLineorNot == false)
       {
          price = OrderOpenPrice();
       }
       bool ret = OrderModify(Ticket, OrderOpenPrice(), price - BuyStoploss_Level_1*PipValue*Point, price + BuyTakeprofit_Level_1*PipValue*Point, 0, Modify_Order_Colour);
       if (ret == false)
       Print("OrderModify() error - ", ErrorDescription(GetLastError()));
     
    }
    
}

我提到的另一件事是关于检查订单是否已经被修改，看它的SL和TP是什么，换句话说，如果你已经在上一个tick上修改了订单，就不要在这个tick上再做。

Funky 2011.09.26 14:57 #5

RaptorUK:

你可以这样做，但这并不是我真正的意思 . .

看一下这个，看看它是否有意义 . .

我提到的另一件事是关于检查订单是否已经被修改，看它的SL和TP是什么，换句话说，如果你已经在上一个tick上修改了订单，就不要在这个tick上再做。

这对我的学习来说是个好东西......我没有意识到可以把(OrderTicket())放在一个函数名称的后面，很酷。这样，我的最新开放订单的票号就有了属性，很酷。这对我现在所做的事情来说是一个非常非常方便的提示，谢谢你。

(OrderType() == OP_SELL && OrderOpenPrice() - Bid > Gap_Level_1*PipValue*Point)))))
            {
                BuyOrderModifyLevel_1(OrderTicket() );    //  <-----  pass the ticket number to the function
                
            }

在这里我看到你做了一个变量Ticket。其实我不知道在代码的这一部分可以声明一个变量。这可以做到吗，因为它在上面的最后部分被赋予了一个值？我明白它是如何工作的，那么，它在这里使用最后一笔交易的订单票号，而不是我的 "不具体的 "OrderTicket()。这是有道理的。对我来说，这将比OrderSelect(i++...)准确得多。

void BuyOrderModifyLevel_1(int Ticket)
{
    if (OrderSelect(Ticket, SELECT_BY_TICKET, MODE_TRADES))
    {
       double price = Ask;
       if (UseAskLineorNot == false)
       {
          price = OrderOpenPrice();
       }
       bool ret = OrderModify(Ticket, OrderOpenPrice(), price - BuyStoploss_Level_1*PipValue*Point, price + BuyTakeprofit_Level_1*PipValue*Point, 0, Modify_Order_Colour);
       if (ret == false)
       Print("OrderModify() error - ", ErrorDescription(GetLastError()));
     
    }
    
}

现在快到凌晨一点了，所以我明天再仔细看看，非常感谢您的时间....。我觉得我可能要把这个逻辑插入 "If_Gap_Levels{}"，而不是 "BuyModify{}"块。我没有解释得太清楚，抱歉。我想这个提示将帮助我检查最新的票据的GAP，然后用那个OP_BUY和BUY_Magic等修改所有以前的订单。

我提到的另一件事是关于检查订单是否已经被修改，看它的SL和TP是什么，换句话说，如果你已经在最后一个tick上修改了订单，就不要在这个tick上再做了 ......这是你想做的吗？

是的，这正是我被卡住的地方...。我只是不知道如何指定这个...... 我是否要做一个NeedsModifying = false的bool值，然后在满足IfGap标准时将其转换为True？我可以想到逻辑，只是不知道语法，不过我从你给我的最后一个EA的提示中学到了，甚至能够提出我最后一句话。再次感谢Raptor。

Simon Gniadkowski 2011.09.26 15:03 #6

Funky:

这对我的学习来说是个好东西......我没有意识到可以把(OrderTicket())放在一个函数名称后面，很酷。这样，我的符合Gap标准的Ticket就归属于BuyOrderModifyLevel_1这个函数了？这对我现在所做的事情来说是一个非常非常方便的提示，谢谢你。

这是函数定义的一部分 ......就像任何标准函数一样，例如OrderModify (https://docs.mql4.com/trading/OrderModify) OrderModify是一个函数，你向它传递变量，至少有5个变量，第6个变量是可选的。你可以用你自己的函数做同样的事情。. .

欢迎你们。夜晚。

Funky 2011.09.26 15:12 #7

RaptorUK:

它是函数定义的一部分 ......就像任何标准函数一样，例如：OrderModify (https://docs.mql4.com/trading/OrderModify) OrderModify是一个函数，你向它传递变量，至少有5个变量，第6个是可选的。你可以用你自己的函数做同样的事。. .

欢迎你们。晚上好。

谢谢你，Raptor....，你在我把最后一句话编辑到那个帖子的时候抓住了我，因为是的，你对我所追求的是正确的......

谢谢你再次提醒我那个.doc......有趣的是，我已经在OrderMofidy上读过那个特别的.doc很多次了。在我看来，那本手册似乎是中文的，然而随着我的进步，更多的高级技巧脱颖而出。我现在会再读一遍，我打赌它会像日光一样清晰，你为我提到的那个功能，不过，谢谢你指出来，让我知道要找它。

我提到的另一件事是关于检查订单是否已经被修改，看它的SL和TP是什么，换句话说，如果你已经在上一个tick上修改了订单，就不要在这个tick上再做了 ...这就是你想做的吗？

是的，这正是我被卡住的地方......。我只是不知道该如何指定...... 我是否要做一个NeedsModifying = false的bool值，然后在满足IfGap标准时将其转换为True？我可以想到逻辑，只是不知道语法，不过我从你给我的最后一个EA的提示中学到了，甚至能够提出我最后一句话。再次感谢Raptor。

晚上好，来自Downunder。

Funky 2011.09.27 07:12 #8

RaptorUK:

它是函数定义的一部分 ......就像任何标准函数一样，例如：OrderModify (https://docs.mql4.com/trading/OrderModify) OrderModify是一个函数，你向它传递变量，至少有5个变量，第6个是可选的。你可以用你自己的函数做同样的事情。. .

欢迎你们。晚上好。

嗨，Raptor。

我利用你给我展示的想法，把事情做得更进一步。我意识到你的代码可以解决我的问题，但是一旦订单达到我的第二个TP水平，就很难管理。

我没有意识到我可以放弃OrderSelect i++，而只是在该等式中选择我自己的票据，所以我试着这样做，因为这将解决我在多笔交易中的所有问题...这是否可行？

如果有人能为我确认这段代码是否有效，我将非常高兴......再次感谢您的支持；)

void BuyPendingOrder_1()
{
    int expire = TimeCurrent() + 60 * 0;
    double price = NormalizeDouble(Ask, NDigits) + PriceOffset_1*PipValue*Point;
    double SL = price - BuyStoploss_1*PipValue*Point;
    if (BuyStoploss_1 == 0) SL = 0;
    double TP = price + BuyTakeprofit_1*PipValue*Point;
    if (BuyTakeprofit_1 == 0) TP = 0;
    if (0 == 0) expire = 0;
    int PendingOrderTicket_1 = OrderSend(Symbol(), OP_BUYSTOP, BuyLots_1, price, 4, SL, TP, "EA_Pending_Order1", BUY_Magic, expire, Blue);
     ///--^^^----^^^ allocate this ticket number to PendingOrderTicket_1 above
    if (PendingOrderTicket_1 == -1)
    {
        Print("OrderSend() error - ", ErrorDescription(GetLastError()));
    }
    
}

void IfGap_Level_1()
{
    if (OrderSelect(PendingOrderTicket_1,SELECT_BY_POS,MODE_TRADES)) ///--<<<---- select ticket number from PendingOrderTicket_1
    {
        if (OrderSymbol() == Symbol() && OrderMagicNumber() == BUY_Magic)
        {
            if ((Gap_Level_1 < 0 && ((OrderType() == OP_BUY && Ask - OrderOpenPrice() < Gap_Level_1*PipValue*Point) ||
            (OrderType() == OP_SELL && OrderOpenPrice() - Bid < Gap_Level_1*PipValue*Point))) ||
            ((Gap_Level_1 > 0 && ((OrderType() == OP_BUY && Ask - OrderOpenPrice() > Gap_Level_1*PipValue*Point) ||
            (OrderType() == OP_SELL && OrderOpenPrice() - Bid > Gap_Level_1*PipValue*Point)))))
            {
                BuyOrderModifyLevel_1; ///--<<<----if PendingOrderTicket_1 is over Gap_Level_1, then proceed to BuyOrderMoidfyLevel_1 section etc
                
            }
        }
    }
    else
    Print("OrderSelect() error - ", ErrorDescription(GetLastError()));
    
}

void BuyOrderModifyLevel_1() 
{
    if (OrderSymbol() == Symbol() && OrderMagicNumber() == BUY_Magic)  ///--<<<----select all trades of that pair and magic
    {
        
            double price = Ask;
            if (UseAskLineorNot == false)
            {
                price = OrderOpenPrice();
            }
            bool ret = OrderModify(OrderTicket(), OrderOpenPrice(), price - BuyStoploss_Level_1*PipValue*Point, price + BuyTakeprofit_Level_1*PipValue*Point, 0, Modify_Order_Colour);
             ///--^^^^^^---- modify all trades of that pair and magic if it made it this far
            if (ret == false)
            Print("OrderModify() error - ", ErrorDescription(GetLastError()));
            
    }
    
}

Simon Gniadkowski 2011.09.27 07:49 #9

做你所建议的事情有问题 . . . .

想象一下，你的EA正在运行 ... ...然后你的MT4由于任何原因被中断，断电，MT4崩溃，电脑需要重启等等 ... ...你的代码不能从它离开的地方接上，因为它不再有PendingOrderTicket_1 的正确值了

Funky 2011.09.27 09:55 #10

RaptorUK:

做你所建议的事情有问题 . . . .

想象一下，你的EA正在运行 ... ...然后你的MT4由于任何原因被中断，断电，MT4崩溃，电脑需要重启，等等 ... ...你的代码不能从它离开的地方接上，因为它不再有PendingOrderTicket_1 的正确值了

嗨，Raptor，再次感谢。

这就是上述代码的唯一问题吗？我认为最坏的情况是，PendingOrderTicket_1不会被修改，会在其SL处关闭。

我使用OrderSelect函数的方式可以吗？

 if (OrderSelect(PendingOrderTicket_1,SELECT_BY_POS,MODE_TRADES)) ///--<<<---- select ticket number from PendingOrderTicket_1

我想我遇到的最大问题是，当OrderTicket_1超过第一个Gap_Level1时，它仍然会修改订单，每当这个标准被满足时。

是这种情况吗？如果是这样，下面的代码能解决这个问题吗？

bool HasBeenExecuted = false;
/// (further up in declared variables^^^)

void BuyOrderModifyLevel_1()
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == BUY_Magic)
      {
        
            double price = Ask;
            if (UseAskLineorNot == false)
            {
                price = OrderOpenPrice();
            }
            bool ret = OrderModify(OrderTicket(), OrderOpenPrice(), price - BuyStoploss_Level_1*PipValue*Point, price + BuyTakeprofit_Level_1*PipValue*Point, 0, Modify_Order_Colour);
             HasBeenExecuted = false;
            if (ret == false)
            Print("OrderModify() error - ", ErrorDescription(GetLastError()));
            {
            HasBeenExecuted = true;
            }
     }    
   
}

或者我可以在CheckGapLevel_1中这样做，这样它就只检查一次？如果是这样，我的做法是否正确？???? 有什么地方我应该放一个 "break "吗？

bool HasBeenExecuted = false;
/// (further up in declared variables^^^)

void IfGap_Level_1()
{
    if (OrderSelect(PendingOrderTicket_1,SELECT_BY_POS,MODE_TRADES))
    {
        if (OrderSymbol() == Symbol() && OrderMagicNumber() == BUY_Magic)
        {
            if ((Gap_Level_1 < 0 && ((OrderType() == OP_BUY && Ask - OrderOpenPrice() < Gap_Level_1*PipValue*Point) ||
            (OrderType() == OP_SELL && OrderOpenPrice() - Bid < Gap_Level_1*PipValue*Point))) ||
            ((Gap_Level_1 > 0 && ((OrderType() == OP_BUY && Ask - OrderOpenPrice() > Gap_Level_1*PipValue*Point) ||
            (OrderType() == OP_SELL && OrderOpenPrice() - Bid > Gap_Level_1*PipValue*Point)))))
            HasBeenExecuted = false;
            {
            HasBeenExecuted = true;                
            BuyOrderModifyLevel_1;
               
            }
        }
    }
    else
    Print("OrderSelect() error - ", ErrorDescription(GetLastError()));
    
}

再次感谢；)

1 2 3 4

新评论