编写"EA 交易"时，MQL5 标准交易类库的使用

Samuel Olowoyo | 27 十二月, 2013

简介

新款 MQL5 程序中带有大量内置标准类库，旨在让交易者和开发人员都尽可能简单地完成 MQL5 “EA 交易”、指标和脚本的开发。

这些类库都位于 MetaTrader 5 客户端文件夹中 MQL5 文件夹里的 \Include\ 文件夹。类库被划分为多个子分类 – Arrays、ChartObjects、Charts、Files、 Indicators、Strings 和 Trade 类。

我们会在本文中详细讲解，如何利用内置交易类编写“EA 交易”。“EA 交易”会以某种策略为基础：如果某规定条件被满足，则会涉及到已建仓位的平仓和修改。

如果您对类的概念和用法已有了解，那么，欢迎您进入 MQL5 新语言为您提供的另一个充满机遇的世界。

另一方面，如果您完全没接触过 MQL5，我建议您先阅读《针对初学者以 MQL5 编写“EA 交易”的分步指南》、《利用 MQL5 面向对象编程法编写 EA 交易》这两篇文章，或是任何其它能够为您提供 MQL5 这一新语言相关指导的文章预热。人们已经撰写了大量的相关文章，能够提供您所需要的知识。

1. 交易类

交易类文件中由多个不同的类构成，而这些类的主旨，是要让那些为个人用途开发 EA 的交易者、以及那些身为程序员却又不想在其“EA 交易” (EA) 开发过程中从零开始的程序员，提供更多的便捷和舒适。

在使用一个类的过程中，您无需知晓该类的内部机制（即其实现开发人员要求的方式），您需要关注的，只有如何利用这个类来解决您的问题。所以，对于任何想要使用它们的人而言，利用内置类库都会便捷许多。本文中，我们着重讨论那些在开发“EA 交易”过程中需要用到的主要的类。

在讨论类的过程中，我们不会纠结于各个类的内部详情，而是详细分析这个类有什么用，我们怎样才能用它来完成开发一个极具盈利能力的 EA 的使命。让我们逐个讨论。

1.1 СAccountInfo 类

CAccountInfo是一个方便用户于客户端中访问所有账户属性或当前已建交易账户信息的类。

为了更好地理解，我们看一看本类中很可能用于 EA 的主要成员函数。在使用一个类之前，我们必须首先创建该类的一个对象；所以，要使用 CAccountInfo 类，我们必须为该类创建一个对象。

我们称其为 myaccount：

//--- The AccountInfo Class Object
CAccountInfo myaccount;

记住：想创建一个类对象，您要使用类名称，后接想要赋予该对象的名称。

现在，我们可以利用 myaccount 对象访问 CAccountInfo 类的公共成员函数。

// returns account number, example 7770
long accountno = myaccount.Login()

// returns Demo trading account, 
// or Real trading account or Contest trading account
string  acc_trading_mode = myaccount.TradeModeDescription();

// returns leverage given to the active account
long acc_leverage = myaccount.Leverage(); 

if (myaccount.TradeAllowed())
{
    // trade is allowed
}
else
{
  // trade is not allowed
}

if (myaccount.TradeExpert())
{
   // Expert Advisor trade is allowed
}
else
{
   // Expert Advisor trade is not allowed
}

// returns account balance in the deposit currency
double acс_balance =  myaccount.Balance(); 

// returns account profit in deposit currency
double acс_profit =  myaccount.Profit();

// returns free margin for active account
double acс_free_margin = myaccount.FreeMargin();

string acс_currency = myaccount.Currency();

double op_profit=myaccount.OrderProfitCheck(_Symbol,ORDER_TYPE_BUY,
1.0,1.2950,1.3235);
Print("The amount of Profit for deal buy EURUSD",
      "at 1.2950 and sell at 1.3235 is: ",op_profit);

// depending on the type of position to open - in our case buy
double price=SymbolInfoDouble(_Symbol,SYMBOL_ASK); 
double margin_req=myaccount.MarginCheck(_Symbol,ORDER_TYPE_BUY,LOT,price);

double acс_fm=myaccount.FreeMarginCheck(_Symbol,ORDER_TYPE_BUY,LOT,price);

double max_lot=myaccount.MaxLotCheck(_Symbol,ORDER_TYPE_BUY,price);

1.2 СSymbolInfo 类

CSymbolInfo类会让用户快速访问当前交易品种所有属性变得非常简单。

要使用此类，我们必须创建此类的一个对象，本例中，我们称其为 mysymbol。

// the CSymbolInfo Class object
CSymbolInfo mysymbol;

 我们看一看该类在编写“EA 交易”过程中可能用到的大多数函数：

// set the symbol name for our CSymbolInfo class Object
mysymbol.Name(_Symbol);

mysymbol.Refresh();

//--- Get the last price quote using the CSymbolInfo 
// class object function
   if (!mysymbol.RefreshRates())
   {
      // error getting latest price quotes 
   }

// check if symbol data are synchronized with server
  if (!mysymbol.IsSynchronized())
   {
     // error! Symbol data aren't synchronized with server
   }

long max_vol = mysymbol.VolumeHigh();

long min_vol = mysymbol.VolumeLow();

datetime qtime = mysymbol.Time();

int spread = mysymbol.Spread();

int stp_level = mysymbol.StopsLevel();

int frz_level = mysymbol.FreezeLevel();

double bid =  mysymbol.Bid();

double max_bid = mysymbol.BidHigh();

double min_bid = mysymbol.BidLow();

double ask = mysymbol.Ask();

double max_ask = mysymbol.AskHigh();

double min_ask = mysymbol.AskLow();

// returns "USD" for USDJPY or USDCAD
string base_currency = mysymbol.CurrencyBase();

double cont_size =  mysymbol.ContractSize();

int s_digits = mysymbol.Digits();

double s_point =  mysymbol.Point();

double min_lot =  mysymbol.LotsMin();

double max_lot =  mysymbol.LotsMax();

double lot_step = mysymbol.LotsStep();

// A normalized current Ask price
double n_price = mysymbol.NormalizePrice(mysymbol.Ask()); 

if (mysymbol.Select())
{
  //Symbol successfully selected
}
else
{
  // Symbol could not be selected
}

if (!mysymbol.Select())
{
   //Symbol not selected, Select the symbol
    mysymbol.Select(true);
}
else
{
 // Symbol already selected, 
 // remove Symbol from market watch window
    mysymbol.Select(false);
}

double init_margin = mysymbol.MarginInitial() ; 

if (mysymbol.TradeMode() == SYMBOL_TRADE_MODE_FULL)
{
 // Full trade allowed for this symbol,
 // no trade restrictions 
}

Print("The trade mode for this symbol is",
       mysymbol.TradeModeDescription());

1.3 СHistoryOrderInfo 类

CHistoryOrderInfo 又是一个会让订单历史属性处理变得非常简单的类。

一旦利用此类创建一个对象之后，我们可以利用该对象访问我们需要用其解决某迫切问题的重要的公共成员函数。

我们将此类的该对象命名为 myhistory。

// The CHistoryOrderInfo Class object
CHistoryOrderInfo myhistory;

我们看一看此类的一些重要函数。

在利用此类获取历史订单详情的过程中，我们需要首先获取历史总订单，然后将订单号传递给我们的类对象 myhistory。

//Select all history orders within a time period
if (HistorySelect(0,TimeCurrent()))  // get all history orders
{
// Get total orders in history
int tot_hist_orders = HistoryOrdersTotal(); 

我们现在迭代可用的总历史订单，并利用类对象获取每个历史订单的详情。

ulong h_ticket; // Order ticket

for (int j=0; j<tot_hist_orders; j++)
{
  h_ticket = HistoryOrderGetTicket(j));

  if (h_ticket>0)
  {
    // First thing is to now set the order Ticket to work with by our class object 

myhistory.Ticket(h_ticket);

ulong o_ticket = myhistory.Ticket();

datetime os_time = myhistory.TimeSetup();

if (myhistory.OrderType() == ORDER_TYPE_BUY)
{
// This is a buy order
}

if(myhistory.State() == ORDER_STATE_REJECTED)
{
// order was rejected, not placed.
}

datetime ot_done =  myhistory.TimeDone();

long o_magic = myhistory.Magic();

long o_posid = myhistory.PositionId();

double o_price =  myhistory.PriceOpen();

string o_symbol =  myhistory.Symbol();

不要忘了，我们是在一个历史总订单的圈内使用这些函数。

1.4 СOrderInfo 类

COrderInfo 是一个方便访问所有挂单属性的类。此类的对象一旦被创建，就可用于此类的公共成员函数。

此类的用法，在某种程度上同上述讲过的 CHistoryOrderInfo 类相似。

我们创建该类的一个对象，并将其命名为 myorder。

// The OrderInfo Class object
COrderInfo myorder;

为了能够利用该类获取挂单详情，我们需要首先获取可用总订单，再按订单号选择它们。

// Select all history orders within a time period
if (HistorySelect(0,TimeCurrent()))   // get all history orders
   {    
     // get total orders
     int o_total = OrdersTotal();

我们会依次通过总订单，并利用创建的对象获取其对应属性。

for (int j=0; j<o_total; j++)
{
 // we must confirm if the order is available for us to get its details using the Select function of the COrderInfo Class

if (myorder.Select(OrderGetTicket(j)) 
   { // order has been selected and can now be manipulated.
   }

ulong o_ticket = myorder.Ticket();

datetime o_setup = myorder.TimeSetup();

if (myorder.Type() == ORDER_TYPE_BUY_LIMIT)
{
// This is a Buy Limit order, etc
}

if (myorder.State() ==ORDER_STATE_STARTED)
{
// order has been checked 
// and may soon be treated by the broker
}

datetime ot_done = myorder.TimeDone();

long o_magic =  myorder.Magic();

long o_posid = myorder.PositionId();

double o_price = myorder.PriceOpen();

double  s_loss = myorder.StopLoss();

double t_profit = myorder.TakeProfit();

double cur_price =  myorder.PriceCurrent();

string o_symbol = myorder.Symbol();

myorder.StoreState();

if (myorder.CheckState() == true)
{
// Our order status or details have changed
}

1.5 CDealInfo 类

CDealInfo 类提供访问所有交易属性或信息记录的权限。此类的对象一旦被创建，我们就可以利用它来获取每一条历史交易相关信息，方式与 CHistoryOrderInfo 类相似。

所以，我们想做的第一件事，就是创建一个此类的对象，并将其命名为 mydeal。

// The DealInfo Class object
CDealInfo myinfo; 

我们从获取历史总交易开始。

if (HistorySelect(0,TimeCurrent()))
   {    
    // Get total deals in history
    int tot_deals = HistoryDealsTotal(); 

我们现在迭代可用的总历史订单，并利用类对象获取每个历史订单的详情。

ulong d_ticket; // deal ticket
for (int j=0; j<tot_deals; j++)
    {
     d_ticket = HistoryDealGetTicket(j);
     if (d_ticket>0)  
     {
      // First thing is to now set the deal Ticket to work with by our class object 

mydeal.Ticket(d_ticket);

ulong deal_ticket = mydeal.Ticket();

long deal_order_no =  mydeal.Order();

datetime d_time = mydeal.Time();

if (mydeal.Type() == DEAL_TYPE_BUY)
{
// This deal was executed as a buy deal type
}

if (mydeal.Entry() == DEAL_ENTRY_IN)
{
// This was an IN entry deal
}

long d_magic = mydeal.Magic();

long d_post_id = mydeal.PositionId();

double d_price = mydeal.Price();

double d_vol = mydeal.Volume();

string d_symbol = mydeal.Symbol();

1.6 CPositionInfo 类

CPositionInfo 类可方便对于当前仓位属性的访问。我们必须创建一个此类的对象，才能用它获取仓位属性。

我们创建该类的一个对象，并将其命名为 myposition。

// The object of the CPositionInfo class
CPositionInfo myposition;

现在我们利用该对象获取敞口仓位详情。我们从获取所有敞口仓位开始：

int pos_total = PositionsTotal();

现在，我们从头到尾看一看所有敞口仓位以获取其详情。

for (int j=0; j<pos_total; j++)
    {

if (myposition.Select(PositionGetSymbol(j)))
{
 // symbol successfully selected, we can now work 
 // on the current open position for this symbol 
}
OR
// when dealing with the current symbol/chart only
if (myposition.Select(_Symbol)) 
{
 // symbol successfully selected, we can now work 
 // on the current open position for this symbol 
}

datetime pos_time = myposition.Time();

if (myposition.Type() == POSITION_TYPE_BUY)
{
// This is a buy position
}

long pos_magic = myposition.Magic();

double pos_vol = myposition.Volume(); // Lots

double pos_op_price = myposition.PriceOpen();

double pos_stoploss = myposition.StopLoss();

double pos_takeprofit = myposition.TakeProfit();

// stores the current state of the position
myposition.StoreState();

if (!myposition.CheckState())
{
  // position status has not changed yet
}

string pos_symbol = myposition.Symbol();

1.7 СTrade 类

CTrade 类会方便对于 MQL5 中交易操作的访问。要使用此类，我们必须创建一个此类的对象，然后再用它来执行必要的交易操作。

我们创建该类的一个对象，并将其命名为 mytrade：

//An object of the CTrade class
CTrade mytrade;

第一步，是对该对象要在交易操作进行过程中用到的大多数参数进行设置。

ulong Magic_No=12345;
mytrade.SetExpertMagicNumber(Magic_No);

ulong Deviation=20;
mytrade.SetDeviationInPoints(Deviation); 

// define the input parameters
double Lots = 0.1;
double SL = 0;
double TP = 0;
// latest Bid price using CSymbolInfo class object
double Oprice = mysymbol.Bid()-_Point*550;
// place (BuyStop) pending order
mytrade.OrderOpen(_Symbol,ORDER_TYPE_SELLSTOP,Lots,0.0,Oprice,
                  SL,TP,ORDER_TIME_GTC,0);

// Select total orders in history and get total pending orders 
// (as shown within the COrderInfo class section). 
// Use the CSymbolInfo class object to get the current ASK/BID price
int Stoploss = 400;
int Takeprofit = 550;
for(int j=0; j<OrdersTotal(); j++)
{
  ulong o_ticket = OrderGetTicket(j);
  if(o_ticket != 0)
  {
   // Stoploss must have been defined
   double SL = mysymbol.Bid() + Stoploss*_Point;   
   // Takeprofit must have been defined  
   double TP = mysymbol.Bid() - Takeprofit*_Point; 
   // lastest ask price using CSymbolInfo class object
   double Oprice = mysymbol.Bid();                 
   // modify pending BuyStop order
   mytrade.OrderModify(o_ticket,Oprice,SL,TP,ORDER_TIME_GTC,0);
  }
}

// Select total orders in history and get total pending orders
// (as shown within the COrderInfo class section). 

int o_total=OrdersTotal();
for(int j=o_total-1; j>=0; j--)
{
   ulong o_ticket = OrderGetTicket(j);
   if(o_ticket != 0)
   {
    // delete the pending Sell Stop order
    mytrade.OrderDelete(o_ticket);
   }
}

// define the input parameters and use the CSymbolInfo class
// object to get the current ASK/BID price
double Lots = 0.1;
// Stoploss must have been defined 
double SL = mysymbol.Ask() – Stoploss*_Point;   
//Takeprofit must have been defined 
double TP = mysymbol.Ask() + Takeprofit*_Point; 
// latest ask price using CSymbolInfo class object
double Oprice = mysymbol.Ask();
// open a buy trade
mytrade.PositionOpen(_Symbol,ORDER_TYPE_BUY,Lots,
                     Oprice,SL,TP,"Test Buy");

if (myposition.Select(_Symbol))
{
  int newStoploss = 250;
  int newTakeprofit = 500;
  double SL = mysymbol.Ask() – newStoploss*_Point;    
  double TP = mysymbol.Ask() + newTakeprofit*_Point;  
  //modify the open position for this symbol
 mytrade.PositionModify(_Symbol,SL,TP);
}

if (myposition.Select(_Symbol))
{
 //close the open position for this symbol
 mytrade.PositionClose(_Symbol);  
}

double Lots = 0.1;
// Stoploss must have been defined 
double SL = mysymbol.Ask() – Stoploss*_Point; 
//Takeprofit must have been defined
double TP = mysymbol.Ask() +Takeprofit*_Point;
// latest ask price using CSymbolInfo class object
double Oprice = mysymbol.Ask();
// open a buy trade
mytrade.Buy(Lots,NULL,Oprice,SL,TP,“Buy Trade”);

//OR
mytrade.Buy(Lots,NULL,0.0,0.0,0.0,“Buy Trade”);
// modify position later

double Lots = 0.1;
// Stoploss must have been defined 
double SL = mysymbol.Bid() + Stoploss*_Point;
//Takeprofit must have been defined
double TP = mysymbol.Bid() - Takeprofit*_Point; 
// latest bid price using CSymbolInfo class object
double Oprice = mysymbol.Bid();
// open a Sell trade
mytrade.Sell(Lots,NULL,Oprice,SL,TP,“Sell Trade”); 

//OR
mytrade.Sell(Lots,NULL,0.0,0.0,0.0,“Sell Trade”); 
//(modify position later)

 double Lot = 0.1;
//Buy price = bar 1 High + 2 pip + spread
 int sprd=mysymbol.Spread();
 double bprice =mrate[1].high + 2*_Point + sprd*_Point;
//--- Buy price
 double mprice=NormalizeDouble(bprice,_Digits); 
//--- Stop Loss
 double stloss = NormalizeDouble(bprice - STP*_Point,_Digits);
//--- Take Profit
 double tprofit = NormalizeDouble(bprice+ TKP*_Point,_Digits);
//--- open BuyStop order
 mytrade.BuyStop(Lot,mprice,_Symbol,stloss,tprofit); 

 double Lot = 0.1;
//--- Sell price = bar 1 Low - 2 pip 
//--- MqlRates mrate already declared
 double sprice=mrate[1].low-2*_Point;
//--- SellStop price
 double slprice=NormalizeDouble(sprice,_Digits);
//--- Stop Loss
 double ssloss=NormalizeDouble(sprice+STP*_Point,_Digits);
//--- Take Profit
 double stprofit=NormalizeDouble(sprice-TKP*_Point,_Digits);
//--- Open SellStop Order
 mytrade.SellStop(Lot,slprice,_Symbol,ssloss,stprofit);

Usage:
//--- Buy price = bar 1 Open  - 5 pip + spread
double Lot = 0.1;
int sprd=mysymbol.Spread();
//--- symbol spread
double bprice = mrate[1].open - 5*_Point + sprd*_Point;
//--- MqlRates mrate already declared
double mprice=NormalizeDouble(bprice,_Digits);
//--- BuyLimit price
//--- place buyLimit order, modify stoploss and takeprofit later
mytrade.BuyLimit(Lot,mprice,_Symbol); 

//--- Sell Limit price = bar 1 Open  + 5 pip
double Lot = 0.1;
//--- MqlRates mrate already declared
double sprice = mrate[1].open + 5*_Point;
//--- SellLimit
double slprice=NormalizeDouble(sprice,_Digits);
//place SellLimit order, modify stoploss and takeprofit later
mytrade.SellLimit(Lot,slprice,_Symbol);

// a trade operation has just been carried out
int return_code = mytrade.ResultRetcode();

string ret_message =  ResultRetcodeDescription();
// display it
Alert("Error code - " , mytrade.ResultRetcode() ,
      "Error message - ", ret_message);

long dl_ticket = mytrade.ResultDeal();

long o_ticket = mytrade.ResultOrder();

double o_volume = mytrade.ResultVolume();

double r_price = mytrade.ResultPrice();

double rq_bid = mytrade.ResultBid;

double rq_ask = mytrade.ResultAsk;

// after a trade operation
// prints the trade request parameters
mytrade.PrintRequest(); 
//prints the trade results
mytrade.PrintResult();  

//determine the Trade operation type for the last Trade request
if (mytrade.RequestAction() == TRADE_ACTION_DEAL)
{
  // this is a market order for an immediate execution
}
else if (mytrade.RequestAction() == TRADE_ACTION_PENDING)
{
  // this is a pending order.
}  

ulong mag_no = mytrade. RequestMagic();

ulong po_ticket =  mytrade.RequestOrder();

string symb = mytrade.RequestSymbol(); 

double Lot = mytrade.RequestVolume();  

double oprice = mytrade.RequestPrice();   

double limitprice = mytrade.RequestStopLimit(); 

double sloss = mytrade.RequestSL();  

double tprofit = mytrade.RequestTP();   

ulong dev = mytrade.RequestDeviation();  

if (mytrade.RequestType() == ORDER_TYPE_BUY)
 {
  // market order Buy was placed in the last request.
 } 

Print("The type of order placed in the last request is :",
      mytrade.RequestTypeDescription());  

Print("The request action used in the last request is :", 
      mytrade.RequestTypeDescription());

Print("The type of order filling policy used",
      " in the last request is :",
      RequestTypeFillingDescription()); 

Trade Class  Request （交易类请求）函数在识别有关下达订单的错误时非常有用。有时候，我们会在下达订单时收到一些错误信息，如果不能马上找出哪里出错，就会让人感觉有点混乱。利用交易类请求函数，我们就能够通过打印发往交易服务器的一些请求参数，找出我们做错的地方。该用法大致如下述代码所示：

 //--- open Buy position and check the result
         if(mytrade.Buy(Lot,_Symbol,mprice,stloss,tprofit))
         //if(mytrade.PositionOpen(_Symbol,ORDER_TYPE_BUY,Lot,mprice,stloss,tprofit)) 
           { //--- Request is completed or order placed           
             Alert("A Buy order at price:", mytrade.ResultPrice() , ", vol:",mytrade.ResultVolume(),
                  " has been successfully placed with deal Ticket#:",mytrade.ResultDeal(),"!!");
            mytrade.PrintResult();
           }
         else
           {
            Alert("The Buy order request at vol:",mytrade.RequestVolume(), ", sl:", mytrade.RequestSL(),
                 ", tp:",mytrade.RequestTP(), ", price:", mytrade.RequestPrice(),
                 " could not be completed -error:",mytrade.ResultRetcodeDescription());
            mytrade.PrintRequest();
            return;
           }

在上述代码中，我们试图在存在错误的情况下，可以识别请求中发送的一些参数。比如说，如果我们未能指定正确的止损价，可能就会收到 Invalid Stops （无效止损价）错误。而利用 mytrade.RequestSL() 显示出止损值，我们就能知道指定的止损价存在什么问题。

讲完每一种类可以如何使用之后，现在，我们该将描述过的一些功能落到实处了。

请注意：我们要在“EA 交易”中使用的所有功能，在上文均有描述。如果您在将要编写的代码中看到任何函数，都建议您参照之前的相关描述。

2. 交易类各项功能的使用

为了演示上述交易类的功能如何使用，我们会编写一个履行下述任务的“EA 交易”。

• 它会检查有无买入或卖出条件，而且，如果条件被满足，它还会根据满足的条件下达买入或卖出订单。
• 如有已建仓位且交易继续按我们的方向进行，我们则会修改该仓位的获利价或止损价。但是，如果交易向我们预期的反方向进行且利润目标未能达成，我们则会平仓。
• 我们的 EA 会用于在日线图上以下述任何货币对进行交易 – GBPUSD、AUDUSD、EURUSD 等。

2.1. 编写“EA 交易”

首先，启动一个新的 MQL5 文档，选择 Expert Advisor (template) ，并点击 Next 按钮：

图 1. 启动新的 MQL5 文档

键入“EA 交易”的名称，并点击 Finish 按钮。稍后我们再手动定义输入参数。

图 2. 为“EA 交易”命名

创建的新文档大致如下。

紧跟 #property 版本行之后，我们纳入要使用的所有交易类。

//+------------------------------------------------------------------+
//|  Include ALL classes that will be used                           |
//+------------------------------------------------------------------+
//--- The Trade Class
#include <Trade\Trade.mqh>
//--- The PositionInfo Class
#include <Trade\PositionInfo.mqh>
//--- The AccountInfo Class
#include <Trade\AccountInfo.mqh>
//--- The SymbolInfo Class
#include <Trade\SymbolInfo.mqh>

接下来，我们定义输入参数：

//+------------------------------------------------------------------+
//|  INPUT PARAMETERS                                              |
//+------------------------------------------------------------------+
input int      StopLoss=100;     // Stop Loss
input int      TakeProfit=240;   // Take Profit
input int      ADX_Period=15;    // ADX Period
input int      MA_Period=15;     // Moving Average Period
input ulong    EA_Magic=99977;   // EA Magic Number
input double   Adx_Min=24.0;     // Minimum ADX Value
input double   Lot=0.1;          // Lots to Trade
input ulong    dev=100;          // Deviation 
input long     Trail_point=32;   // Points to increase TP/SL
input int      Min_Bars = 20;    // Minimum bars required for Expert Advisor to trade
input double   TradePct = 25;    // Percentage of Account Free Margin to trade

再来指定将在本“EA 交易”代码中使用的其它参数：

//+------------------------------------------------------------------+
//|  OTHER USEFUL PARAMETERS                                         |
//+------------------------------------------------------------------+
int adxHandle;                     // handle for our ADX indicator
int maHandle;                    // handle for our Moving Average indicator
double plsDI[],minDI[],adxVal[]; // Dynamic arrays to hold the values of +DI, -DI and ADX values for each bars
double maVal[];                  // Dynamic array to hold the values of Moving Average for each bars
double p_close;                    // Variable to store the close value of a bar
int STP, TKP;                   // To be used for Stop Loss, Take Profit 
double TPC;                        // To be used for Trade percent

现在，我们为已经纳入的每一个类创建一个对象：

//+------------------------------------------------------------------+
//|  CREATE CLASS OBJECTS                                            |
//+------------------------------------------------------------------+
//--- The Trade Class Object
CTrade mytrade;
//--- The PositionInfo Class Object
CPositionInfo myposition;
//--- The AccountInfo Class Object
CAccountInfo myaccount;
//--- The SymbolInfo Class Object
CSymbolInfo mysymbol;

现在我们要做的，就是对将要使用的一些函数进行定义，方便我们自己的工作。

一旦定义完毕，我们到 OnInit() 与 OnTick() 函数的必要部分中去调用它们即可。

2.1.1 checkTrading 函数

此函数会被用于执行所有的初步检查，查看我们的“EA 交易”能否交易。如果此函数返回 true，我们的 EA 则会继续执行交易；否则，EA 不会执行任何交易。

//+------------------------------------------------------------------+
//|  Checks if our Expert Advisor can go ahead and perform trading   |
//+------------------------------------------------------------------+
bool checkTrading()
{
  bool can_trade = false;
  // check if terminal is syncronized with server, etc
  if (myaccount.TradeAllowed() && myaccount.TradeExpert() && mysymbol.IsSynchronized())
  {
    // do we have enough bars?
    int mbars = Bars(_Symbol,_Period);
    if(mbars >Min_Bars)
    {
      can_trade = true;
    }
  }
  return(can_trade);
}

我们声明一个布尔数据类型 can_trade 并设定为 false。我们利用 CAccountInfo 类的对象来检查是否允许交易，以及是否允许“EA 交易”在该账户上交易。我们还利用 CSymbolInfo 类的对象来检查终端是否与交易服务器同步。

一旦上述三个条件得到满足，我们就会检查当前柱的总数是否大于 EA 交易所需的最少柱数。如果此函数返回 true，则我们的 EA 会执行交易活动；否则，我们的 EA 不会从事任何交易活动，直到此函数内的相关条件被满足。

正如您所见，我们已经决定利用标准交易类库的必要对象，将所有必要的交易检查活动纳入到此函数中来。

2.1.2 ConfirmMargin 函数

//+------------------------------------------------------------------+
//|  Confirms if margin is enough to open an order
//+------------------------------------------------------------------+
bool ConfirmMargin(ENUM_ORDER_TYPE otype,double price)
  {
   bool confirm = false;
   double lot_price = myaccount.MarginCheck(_Symbol,otype,Lot,price); // Lot price/ Margin    
   double act_f_mag = myaccount.FreeMargin();                        // Account free margin 
   // Check if margin required is okay based on setting
   if(MathFloor(act_f_mag*TPC)>MathFloor(lot_price))
     {
      confirm =true;
     }
    return(confirm);
  }

我们利用 CAccountInfo 类的对象，根据我们只会使用账户中特定百分比的可用预付款来下达订单的设置，确定是否有足够的预付款来进行交易。

如果要求的账户可用预付款百分比大于订单要求的预付款，则此函数返回 true；否则返回 false。如此一来，我们只会在该函数返回 true 的情况下下达订单。此函数将订单类型作为输入参数。

2.1.3 checkBuy 函数

//+------------------------------------------------------------------+
//|  Checks for a Buy trade Condition                                |
//+------------------------------------------------------------------+
bool checkBuy()
{
  bool dobuy = false;
  if ((maVal[0]>maVal[1]) && (maVal[1]>maVal[2]) &&(p_close > maVal[1]))
  {
    // MA increases upwards and previous price closed above MA
    if ((adxVal[1]>Adx_Min)&& (plsDI[1]>minDI[1]))
    {
      // ADX is greater than minimum and +DI is greater tha -DI for ADX
      dobuy = true;
    }
  }
  return(dobuy);
}

我们决定将建立一个买入交易的条件打包到此函数中。这里的任何类对象功能，我们都没用过。我们要检查存不存在这样的条件：移动平均线指标值持续上升，且前一柱的收盘价高于此点位移动平均线的值。

我们还想要这样的情况：ADX 指标值大于输入参数中设定的所需最小值，而且 ADX 指标的 + DI 高于 - DI 值。一旦上述条件得到满足，我们就让 EA 建立一个买入订单。

2.1.4 checkSell 函数

//+------------------------------------------------------------------+
//|  Checks for a Sell trade Condition                               |
//+------------------------------------------------------------------+
bool checkSell()
{
  bool dosell = false;
  if ((maVal[0]<maVal[1]) && (maVal[1]<maVal[2]) &&(p_close < maVal[1]))
  {
    // MA decreases downwards and previuos price closed below MA
    if ((adxVal[1]>Adx_Min)&& (minDI[1]>plsDI[1]))
    {
      // ADX is greater than minimum and -DI is greater tha +DI for ADX
      dosell = true;
    }
  }
  return(dosell);
} 

此函数的检查项与 CheckBuy 函数正好相反。此函数中的任何类对象，我们也都没用过。此函数会检查存不存在这样的条件：移动平均线指标值持续下降，且前一柱的收盘价低于此点位移动平均线的值。

我们还想要这样的情况：ADX 指标值大于输入参数中设定的所需最小值，而且 ADX 指标的 - DI 高于 + DI 值。一旦上述条件得到满足，我们就让 EA 建立一个卖出订单。

//+------------------------------------------------------------------+
//|  Checks if an Open position can be closed                        |
//+------------------------------------------------------------------+
bool checkClosePos(string ptype, double Closeprice)
{
   bool mark = false;
   if (ptype=="BUY")
   {
      // Can we close this position
     if (Closeprice < maVal[1]) // Previous price close below MA
      {
         mark = true;
      }
   }
   if (ptype=="SELL")
   {
      // Can we close this position
      if (Closeprice > maVal[1]) // Previous price close above MA
      {
         mark = true;
      }
   }
   return(mark);
}

此函数用于检查当前的敞口仓位可否平仓。此函数用于监控前一柱的收盘价与该点位的移动平均线指标值相比，孰高孰低（取决于交易方向）。

如有任何一个条件被满足，则此函数返回 true，之后，我们就可以静待 EA 平仓了。此函数有两个输入参数，订单类型（此次的名称为买入或卖出），以及前一柱的收盘价。

2.1.6 ClosePosition 函数

//+------------------------------------------------------------------+
//| Checks and closes an open position                                                                |
//+------------------------------------------------------------------+
bool ClosePosition(string ptype,double clp)
  {
   bool marker=false;
     
      if(myposition.Select(_Symbol)==true)
        {
         if(myposition.Magic()==EA_Magic && myposition.Symbol()==_Symbol)
           {
            //--- Check if we can close this position
            if(checkClosePos(ptype,clp)==true)
              {
               //--- close this position and check if we close position successfully?
               if(mytrade.PositionClose(_Symbol)) //--- Request successfully completed 
                 {
                  Alert("An opened position has been successfully closed!!");
                  marker=true;
                 }
               else
                 {
                  Alert("The position close request could not be completed - error: ",
                       mytrade.ResultRetcodeDescription());
                 }
              }
           }
        }
      return(marker);
     }

此函数是上述函数 (checkclosepos) 的实际使用者。它会利用 CPositionInfo 与 CTrade 类的对象。此函数会利用 CPositionInfo 类的对象来检查 EA 建立的仓位和当前交易品种的敞口仓位。如果发现任何仓位，则会检查可否利用 checkclosepos 函数平仓。

如果 checkclosepos 函数返回 true，此函数则利用CTrade 类的对象来平仓，并显示平仓操作的结果。如果平仓成功，此函数则返回 true，否则返回 false。

此函数采用两个输入参数（仓位名称 ，BUY 或 SELL 以及 前一柱收盘价）。上述参数被实际传递给使用它们的 checkclosepos 函数。

2.1.7 CheckModify 函数

//+------------------------------------------------------------------+
//|  Checks if we can modify an open position                        |
//+------------------------------------------------------------------+
bool CheckModify(string otype,double cprc)
{
   bool check=false;
   if (otype=="BUY")
   {
      if ((maVal[2]<maVal[1]) && (maVal[1]<maVal[0]) && (cprc>maVal[1]) && (adxVal[1]>Adx_Min))
      {
         check=true;
      }
   }
   else if (otype=="SELL")
   {
      if ((maVal[2]>maVal[1]) && (maVal[1]>maVal[0]) && (cprc<maVal[1]) && (adxVal[1]>Adx_Min))
      {
         check=true;
      }
   }
   return(check);
} 

此函数用于检查有无可以确认某已建仓可否修改的条件。它会利用订单类型名称和前一柱收盘价格作为输入参数。

此函数的作用，就是检查移动平均线是否仍在持续上升，前一柱收盘价是否仍高于此点位的移动平均值，ADX 的值是否大于所要求的最小值（针对某买入仓位）；同时，它还会检查移动平均线是否仍在持续下降，以及前一柱收盘价是否低于该点位的移动平均值（针对某卖出仓位）。根据我们具备的仓位类型，如有任何条件被满足，EA 会考虑修改仓位。

此函数采用两个输入参数（仓位名称 ，买入或卖出，以及 前一柱收盘价）。

2.1.8 Modify 函数

//+------------------------------------------------------------------+
//| Modifies an open position                                        |
//+------------------------------------------------------------------+
   void Modify(string ptype,double stpl,double tkpf)
     {
       //--- New Stop Loss, new Take profit, Bid price, Ask Price
      double ntp,nsl,pbid,pask;                  
      long tsp=Trail_point;
       //--- adjust for 5 & 3 digit prices
      if(_Digits==5 || _Digits==3) tsp=tsp*10;   
       //--- Stops Level
      long stplevel= mysymbol.StopsLevel();      
       //--- Trail point must not be less than stops level
      if(tsp<stplevel) tsp=stplevel;
      if(ptype=="BUY")
        {
          //--- current bid price
         pbid=mysymbol.Bid();           
         if(tkpf-pbid<=stplevel*_Point)
           {
            //--- distance to takeprofit less or equal to Stops level? increase takeprofit
            ntp = pbid + tsp*_Point;
            nsl = pbid - tsp*_Point;
           }
         else
           {
            //--- distance to takeprofit higher than Stops level? dont touch takeprofit
            ntp = tkpf;
            nsl = pbid - tsp*_Point;
           }
        }
      else //--- this is SELL
        {
          //--- current ask price
         pask=mysymbol.Ask();            
         if(pask-tkpf<=stplevel*_Point)
           {
            ntp = pask - tsp*_Point;
            nsl = pask + tsp*_Point;
           }
         else
           {
            ntp = tkpf;
            nsl = pask + tsp*_Point;
           }
        }
      //--- modify and check result
      if(mytrade.PositionModify(_Symbol,nsl,ntp))  
        {
          //--- Request successfully completed    
         Alert("An opened position has been successfully modified!!");
         return;
        }
      else
        {
         Alert("The position modify request could not be completed - error: ",
               mytrade.ResultRetcodeDescription());
         return;
        }

     }

 此函数会利用上述函数 (checkmodify) 完成其工作。它会利用 CSymbolInfo 与 CTrade 类的对象。首先，我们声明四个双精度数据类型，用以保存新的获利价、止损价、卖价和买价。之后，我们声明一个新的长数据类型 tsp ，用以保存输入参数部分中设定的 Trail_point 值。

随后将追踪点值 (tsp) 针对 5 位和 3 位价格调整。然后，我们利用 CSymbolInfo 对象获取止损价位，并确保我们要添加的追踪点不低于要求的止损价位。如果低于止损价位，我们则采用止损值。

根据持仓类型，我们利用 CSymbolInfo 类对象来获取卖价或买价（视情况而定）。如果当前卖价或买价与初始获利价之间的差异低于或等于止损价，则我们决定对止损价与获利价两者同时进行调整；否则，只调整止损值。

之后，我们利用 CTrade 类对象来修改仓位的止损和获利价。还会根据交易结果返回代码，显示成功或失败信息。

为了减少工作量，我们已经完成了一些用户定义函数的定义。现在我们准备处理 EA 代码部分。

2.1.9 OnInit 部分

//--- set the symbol name for our SymbolInfo Object
   mysymbol.Name(_Symbol);
// Set Expert Advisor Magic No using our Trade Class Object
   mytrade.SetExpertMagicNumber(EA_Magic);
// Set Maximum Deviation using our Trade class object
   mytrade.SetDeviationInPoints(dev);
//--- Get handle for ADX indicator
   adxHandle=iADX(NULL,0,ADX_Period);
//--- Get the handle for Moving Average indicator
   maHandle=iMA(_Symbol,Period(),MA_Period,0,MODE_EMA,PRICE_CLOSE);
//--- What if handle returns Invalid Handle
   if(adxHandle<0 || maHandle<0)
     {
      Alert("Error Creating Handles for MA, ADX indicators - error: ",GetLastError(),"!!");
      return(1);
     }
   STP = StopLoss;
   TKP = TakeProfit;
//--- Let us handle brokers that offers 5 or 3 digit prices instead of 4
   if(_Digits==5 || _Digits==3)
     {
      STP = STP*10;
      TKP = TKP*10;
     }
   
//--- Set trade percent
    TPC = TradePct;
    TPC = TPC/100;
//---

我们决定设置 CSymbolInfo 类对象的当前交易品种。我们还要利用 CTrade 类对象设置“EA 交易”的幻数和偏离值（点数）。此后，我们决定获取指标的句柄，如果获取失败，还要显示错误信息。

接下来，我们决定调整 3 位和 5 位价格的止损价与获利价；此外，我们还将交易使用的可用账户预付款转换为百分比。

2.1.10 OnDeinit 部分

//--- Release our indicator handles
   IndicatorRelease(adxHandle);
   IndicatorRelease(maHandle);

这里我们要释放所有的指标句柄。

2.1.11. OnTick 部分

//--- check if EA can trade
    if (checkTrading() == false) 
   {
      Alert("EA cannot trade because certain trade requirements are not meant");
      return;
   }
//--- Define the MQL5 MqlRates Structure we will use for our trade
   MqlRates mrate[];          // To be used to store the prices, volumes and spread of each bar
/*
     Let's make sure our arrays values for the Rates, ADX Values and MA values 
     is store serially similar to the timeseries array
*/
// the rates arrays
   ArraySetAsSeries(mrate,true);
// the ADX values arrays
   ArraySetAsSeries(adxVal,true);
// the MA values arrays
   ArraySetAsSeries(maVal,true);
// the minDI values array
   ArraySetAsSeries(minDI,true);
// the plsDI values array
   ArraySetAsSeries(plsDI,true);

这里我们要做的第一件事，就是检查并确认 EA 应不应该交易。如果 checktrade 函数返回 false，则 EA 会等待下一次价格跳动，并再次检查。

此后，我们声明一个 MQL5 MqlRates 结构以获取每个柱的价格，然后再用 ArraySetAsSeries 函数设置所有的必需数组。

//--- Get the last price quote using the SymbolInfo class object function
   if (!mysymbol.RefreshRates())
     {
      Alert("Error getting the latest price quote - error:",GetLastError(),"!!");
      return;
     }

//--- Get the details of the latest 3 bars
   if(CopyRates(_Symbol,_Period,0,3,mrate)<0)
     {
      Alert("Error copying rates/history data - error:",GetLastError(),"!!");
      return;
     }

//--- EA should only check for new trade if we have a new bar
// lets declare a static datetime variable
   static datetime Prev_time;
// lest get the start time for the current bar (Bar 0)
   datetime Bar_time[1];
   //copy the current bar time
   Bar_time[0] = mrate[0].time;
// We don't have a new bar when both times are the same
   if(Prev_time==Bar_time[0])
     {
      return;
     }
//Save time into static varaiable, 
   Prev_time = Bar_time[0]; 

我们利用 CSymbolInfo 类对象来获取当前报价，再将当前柱价格复制到 mrates 数组。紧接着决定检查是否存在新柱。

如有新柱，我们的 EA 就会继续检查买入或卖出条件是否已满足；否则，它就会等到有新柱出现为止。

//--- Copy the new values of our indicators to buffers (arrays) using the handle
   if(CopyBuffer(adxHandle,0,0,3,adxVal)<3 || CopyBuffer(adxHandle,1,0,3,plsDI)<3
      || CopyBuffer(adxHandle,2,0,3,minDI)<3)
     {
      Alert("Error copying ADX indicator Buffers - error:",GetLastError(),"!!");
      return;
     }
   if(CopyBuffer(maHandle,0,0,3,maVal)<3)
     {
      Alert("Error copying Moving Average indicator buffer - error:",GetLastError());
      return;
     }
//--- we have no errors, so continue
// Copy the bar close price for the previous bar prior to the current bar, that is Bar 1

   p_close=mrate[1].close;  // bar 1 close price

这里，我们利用 CopyBuffer 函数将指标缓冲区放入数组；如果过程中出现错误，则予显示。前一柱收盘价格被复制。

//--- Do we have positions opened already?
  bool Buy_opened = false, Sell_opened=false; 
   if (myposition.Select(_Symbol) ==true)  // we have an opened position
    {
      if (myposition.Type()== POSITION_TYPE_BUY)
       {
            Buy_opened = true;  //It is a Buy
          // Get Position StopLoss and Take Profit
           double buysl = myposition.StopLoss();      // Buy position Stop Loss
           double buytp = myposition.TakeProfit();    // Buy position Take Profit
           // Check if we can close/modify position
           if (ClosePosition("BUY",p_close)==true)
             {
                Buy_opened = false;   // position has been closed
                return; // wait for new bar
             }
           else
           {
              if (CheckModify("BUY",p_close)==true) // We can modify position
              {
                  Modify("BUY",buysl,buytp);
                  return; // wait for new bar
              }
           } 
       }
      else if(myposition.Type() == POSITION_TYPE_SELL)
       {
            Sell_opened = true; // It is a Sell
            // Get Position StopLoss and Take Profit
            double sellsl = myposition.StopLoss();    // Sell position Stop Loss
            double selltp = myposition.TakeProfit();  // Sell position Take Profit
             if (ClosePosition("SELL",p_close)==true)
             {
               Sell_opened = false;  // position has been closed
               return;   // wait for new bar
             }
             else
             {
                 if (CheckModify("SELL",p_close)==true) // We can modify position
                 {
                     Modify("SELL",sellsl,selltp);
                     return;  //wait for new bar
                 }
             } 
       }
    } 

我们利用 CPositionInfo 类对象进行选择，并检查当前交易品种是否有敞口仓位。如果存在仓位，且为买入，我们则将 Buy_opened 设置为 true，再利用 CPositionInfo 类对象获取仓位的止损价与获利价。我们利用之前定义的一个函数 - ClosePosition 来确定可否平仓。如果函数返回 true，则已平仓；我们将 Buy_opened 设置为 false，初始买入仓位刚刚平仓。现在，EA 就会等待新的价格跳动。

但是，如果函数返回 false，则尚未平仓。现在就该检查我们能否修改仓位。利用我们之前定义的 CheckModify 函数实现。如果函数返回 true，则意味着仓位可以修改；我们利用 Modify 函数来修改仓位。

另一方面，如果存在仓位且为卖出，我们则将 Sell_opened 设置为 true 并利用 CPositionInfo 类对象来获取仓位的止损价与获利价。重复针对买入仓位执行的同一步骤，从而看看仓位可否平仓或修改。

      if(checkBuy()==true)
        {
         //--- any opened Buy position?
         if(Buy_opened)
           {
            Alert("We already have a Buy position!!!");
            return;    //--- Don't open a new Sell Position
           }

         double mprice=NormalizeDouble(mysymbol.Ask(),_Digits);                //--- latest ask price
         double stloss = NormalizeDouble(mysymbol.Ask() - STP*_Point,_Digits); //--- Stop Loss
         double tprofit = NormalizeDouble(mysymbol.Ask()+ TKP*_Point,_Digits); //--- Take Profit
         //--- check margin
         if(ConfirmMargin(ORDER_TYPE_BUY,mprice)==false)
           {
            Alert("You do not have enough money to place this trade based on your setting");
            return;
           }
         //--- open Buy position and check the result
         if(mytrade.Buy(Lot,_Symbol,mprice,stloss,tprofit))
         //if(mytrade.PositionOpen(_Symbol,ORDER_TYPE_BUY,Lot,mprice,stloss,tprofit)) 
           {
               //--- Request is completed or order placed
             Alert("A Buy order has been successfully placed with deal Ticket#:",
                  mytrade.ResultDeal(),"!!");
           }
         else
           {
            Alert("The Buy order request at vol:",mytrade.RequestVolume(), 
                  ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(),
                  ", price:", mytrade.RequestPrice(), 
                     " could not be completed -error:",mytrade.ResultRetcodeDescription());
            return;
           }
        }

或者，我们也可以利用 PositionOpen 函数。

      if(checkBuy()==true)
        {
         //--- any opened Buy position?
         if(Buy_opened)
           {
            Alert("We already have a Buy position!!!");
            return;    //--- Don't open a new Sell Position
           }

         double mprice=NormalizeDouble(mysymbol.Ask(),_Digits);               //--- latest Ask price
         double stloss = NormalizeDouble(mysymbol.Ask() - STP*_Point,_Digits); //--- Stop Loss
         double tprofit = NormalizeDouble(mysymbol.Ask()+ TKP*_Point,_Digits); //--- Take Profit
         //--- check margin
         if(ConfirmMargin(ORDER_TYPE_BUY,mprice)==false)
           {
            Alert("You do not have enough money to place this trade based on your setting");
            return;
           }
         //--- open Buy position and check the result
         //if(mytrade.Buy(Lot,_Symbol,mprice,stloss,tprofit))
         if(mytrade.PositionOpen(_Symbol,ORDER_TYPE_BUY,Lot,mprice,stloss,tprofit))
           {
              //--- Request is completed or order placed            
              Alert("A Buy order has been successfully placed with deal Ticket#:",
            mytrade.ResultDeal(),"!!");
           }
         else
           {
            Alert("The Buy order request at vol:",mytrade.RequestVolume(), 
                    ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(), 
                    ", price:", mytrade.RequestPrice(), 
                    " could not be completed -error:",mytrade.ResultRetcodeDescription());
            return;
           }
        }

这里，我们利用 checkbuy 函数来检查  有无买入设置；如果返回 true，则我们的买入交易条件已被满足。如果我们已有一个买入仓位，并且不想下达新订单。那么，我们可以使用 CSymbolInfo 类对象来获取当前买价，并且根据要求计算出止损价与获利价。

我们还使用 ConfirmMargin 函数来检查下达订单所允许的账户百分比，是否大于下达此订单要求的预付款比例。如果函数返回 true，我们则继续进行交易；否则不执行交易。

我们利用 CTrade 类对象下达订单，并利用相同的调用对象来获取交易操作返回代码。会根据交易结果显示一条信息。

      if(checkSell()==true)
        {
         //--- any opened Sell position?
         if(Sell_opened)
           {
            Alert("We already have a Sell position!!!");
            return;    //--- Wait for a new bar
           }

         double sprice=NormalizeDouble(mysymbol.Bid(),_Digits);             //--- latest Bid price
         double ssloss=NormalizeDouble(mysymbol.Bid()+STP*_Point,_Digits);   //--- Stop Loss
         double stprofit=NormalizeDouble(mysymbol.Bid()-TKP*_Point,_Digits); //--- Take Profit
         //--- check margin
         if(ConfirmMargin(ORDER_TYPE_SELL,sprice)==false)
           {
            Alert("You do not have enough money to place this trade based on your setting");
            return;
           }
         //--- Open Sell position and check the result
         if(mytrade.Sell(Lot,_Symbol,sprice,ssloss,stprofit))
         //if(mytrade.PositionOpen(_Symbol,ORDER_TYPE_SELL,Lot,sprice,ssloss,stprofit))
           {
               //---Request is completed or order placed            
               Alert("A Sell order has been successfully placed with deal Ticket#:",mytrade.ResultDeal(),"!!");
           }
         else
           {
            Alert("The Sell order request at Vol:",mytrade.RequestVolume(), 
                    ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(), 
                    ", price:", mytrade.RequestPrice(), 
                    " could not be completed -error:",mytrade.ResultRetcodeDescription());
            return;
           }

        }

或者，我们也可以利用 PositionOpen 函数：

      if(checkSell()==true)
        {
         //--- any opened Sell position?
         if(Sell_opened)
           {
            Alert("We already have a Sell position!!!");
            return;    //--- Wait for a new bar
           }

         double sprice=NormalizeDouble(mysymbol.Bid(),_Digits);             //--- latest Bid price
         double ssloss=NormalizeDouble(mysymbol.Bid()+STP*_Point,_Digits);   //--- Stop Loss
         double stprofit=NormalizeDouble(mysymbol.Bid()-TKP*_Point,_Digits); //--- Take Profit
         //--- check margin
         if(ConfirmMargin(ORDER_TYPE_SELL,sprice)==false)
           {
            Alert("You do not have enough money to place this trade based on your setting");
            return;
           }
         //--- Open Sell position and check the result
         //if(mytrade.Sell(Lot,_Symbol,sprice,ssloss,stprofit))
         if(mytrade.PositionOpen(_Symbol,ORDER_TYPE_SELL,Lot,sprice,ssloss,stprofit))
           {
             //---Request is completed or order placed            
             Alert("A Sell order has been successfully placed with deal Ticket#:",mytrade.ResultDeal(),"!!");
           }
         else
           {
            Alert("The Sell order request at Vol:",mytrade.RequestVolume(),
                 ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(), 
                 ", price:", mytrade.RequestPrice(), 
                   " could not be completed -error:",mytrade.ResultRetcodeDescription());
            return;
           }
        }

就像我们针对买入的做法一样，我们利用 Checksell 函数来检查卖出设置。如其返回 true ，而且我们没有已经敞口的卖出仓位，则利用 ConfirmMargin 函数来检查是否有足够的资金下达订单。如果 ConfirmMargin 返回 true，则 CTrade 类对象会被用于下达订单，而且，根据交易服务器的响应，利用 CTrade 类对象函数显示交易结果。

到现在为止，我们已经学习了在编写“EA 交易”的过程中，我们可以如何使用交易类库。接下来要做的事情，就是利用策略测试程序测试我们的“EA 交易”，同时观察其性能表现。

编译 EA 代码，再将其载入策略测试程序中。

         图 3. “EA 交易”编译报告

于 GBPUSD 日线图上利用缺省设置：获利 - 270，止损 - 100 和追踪点 (TP/SL) - 32，我们得到如下结果：

图 4. “EA 交易”测试报告 - GBPUSD 日线图

图 5. “EA 交易”测试图形结果 - GBPUSD 日线图

图 6. “EA 交易”测试报告显示出敞口仓位的修改 - GBPUSD 日线图

图 7. GBPUSD 日线图的“EA 交易”测试图表报告

您可以随意就带有不同获利价、止损价及追踪点设置的任何其它交易品种日线图上的 EA 展开测试，再看看您得到了什么。

但是，您要明白，该“EA 交易”仅为测试用途编写……

现在我们来看看，如何利用其它类 （COrderInfo、CHistoryOrderInfo 和 CDealInfo）来获取订单/交易详情。

2.2 打开/删除挂单  

我们会在本例中编写一个简单的“EA 交易”，如果有买入或卖出设置条件被分别满足，它就会下达一个挂单（BuyStop 或 SellStop）。

2.2.1 包含要求的类

//+------------------------------------------------------------------+
//|  Include ALL classes that will be used                           |
//+------------------------------------------------------------------+
//--- The Trade Class
#include <Trade\Trade.mqh>
//--- The PositionInfo Class
#include <Trade\PositionInfo.mqh>
//--- The SymbolInfo Class
#include <Trade\SymbolInfo.mqh>
//--- The OrderInfo Class
#include <Trade\OrderInfo.mqh>

我们已经纳入了将在这个简单的“EA 交易”中使用的四个类。也在上述的示例中进行了阐释。

我不会就此“EA 交易”的每一个部分进行阐释，因为它们都与上述内容类似。但是，“EA 交易”中最基本的、说明我们要在该部分讨论哪些内容的环节，我会一一说明。

唯一不同的是我们决定在全局范围内声明 MqlRates mrate[]。

//--- Define the MQL5 MqlRates Structure we will use for our trade
   MqlRates mrate[];     // To be used to store the prices, volumes and spread of each bar

一旦我们纳入类后，还不能忘了创建每个类的对象：

//+------------------------------------------------------------------+
//|  CREATE CLASS OBJECTS                                            |
//+------------------------------------------------------------------+
//--- The CTrade Class Object
CTrade mytrade;
//--- The CPositionInfo Class Object
CPositionInfo myposition;
//--- The CSymbolInfo Class Object
CSymbolInfo mysymbol;
//--- The COrderInfo Class Object
COrderInfo myorder;

CheckBuy() 和 CheckSell() 函数与之前讲过的“EA 交易”中的情况一样。

这里我们想做的是，有买入设置时下达一个 BUYSTOP 订单；有卖出设置时下达一个 SELLSTOP 订单。

现在，我们来仔细看看为便于使用而创建的几个函数。

2.2.2 CountOrders 函数

//+------------------------------------------------------------------+
//|  Count Total Orders for this expert/symbol                             |
//+------------------------------------------------------------------+
int CountOrders()
  {
   int mark=0;

   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(myorder.Select(OrderGetTicket(i)))
        {
         if(myorder.Magic()==EA_Magic && myorder.Symbol()==_Symbol) mark++;
        }
     }
   return(mark);
  }

此函数用于获取某个时间点的总挂单。

我们利用 COrderInfo 类的对象来检查订单详情，检查其是否已利用 myorder.Select() 函数成功选定。

如果我们类对象返回的幻数及返回的交易品种正是我们想要的，则“EA 交易”就会下达订单，然后被计数并存储于 mark 变量中。

2.2.3 DeletePending 函数

//+------------------------------------------------------------------+
//| Checks and Deletes a pending order                                |
//+------------------------------------------------------------------+
bool DeletePending()
  {
   bool marker=false;
//--- check all pending orders
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(myorder.Select(OrderGetTicket(i)))
        {
         if(myorder.Magic()==EA_Magic && myorder.Symbol()==_Symbol)
           {
            //--- check if order has stayed more than two bars time
            if(myorder.TimeSetup()<mrate[2].time)
              {
               //--- delete this pending order and check if we deleted this order successfully?
                if(mytrade.OrderDelete(myorder.Ticket())) //Request successfully completed 
                  {
                    Alert("A pending order with ticket #", myorder.Ticket(), " has been successfully deleted!!");
                    marker=true;
                  }
                 else
                  {
                    Alert("The pending order # ",myorder.Ticket(),
                             " delete request could not be completed - error: ",mytrade.ResultRetcodeDescription());
                  }

              }
           }
        }
     }
   return(marker);
  }

就像 countorder 函数一样，此函数也利用 COrderInfo 类函数来获取订单属性。此函数会检查三柱前是否有任何挂单设置（挂单设置时间早于 mrate[2].time），而且尚未被触发。

如有任何订单属于此类，则利用 CTrade 类函数 OrderDelete 删除该订单。如果成功，此函数会返回 true；否则返回 false。

一旦有新柱形成，就在检查有无新交易设置之前，立即使用上述两个函数。我们要确保每个时间点下达的挂单都不超过三个。为此，我们采用下述代码：

// do we have more than 3 already placed pending orders
if (CountOrders()>3) 
  {
     DeletePending(); 
     return;  
  }

2.2.4 下达挂单

   if(checkBuy()==true)
     {
      Alert("Total Pending Orders now is :",CountOrders(),"!!");
      //--- any opened Buy position?
      if(Buy_opened)
        {
         Alert("We already have a Buy position!!!");
         return;    //--- Don't open a new Sell Position
        }
      //Buy price = bar 1 High + 2 pip + spread
      int sprd=mysymbol.Spread();
      double bprice =mrate[1].high + 10*_Point + sprd*_Point;
      double mprice=NormalizeDouble(bprice,_Digits);               //--- Buy price
      double stloss = NormalizeDouble(bprice - STP*_Point,_Digits); //--- Stop Loss
      double tprofit = NormalizeDouble(bprice+ TKP*_Point,_Digits); //--- Take Profit
      //--- open BuyStop order
      if(mytrade.BuyStop(Lot,mprice,_Symbol,stloss,tprofit))
      //if(mytrade.OrderOpen(_Symbol,ORDER_TYPE_BUY_STOP,Lot,0.0,bprice,stloss,tprofit,ORDER_TIME_GTC,0)) 
        {
         //--- Request is completed or order placed
         Alert("A BuyStop order has been successfully placed with Ticket#:",mytrade.ResultOrder(),"!!");
         return;
        }
      else
        {
         Alert("The BuyStop order request at vol:",mytrade.RequestVolume(), 
                 ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(),
               ", price:", mytrade.RequestPrice(), 
                 " could not be completed -error:",mytrade.ResultRetcodeDescription());
         return;
        }
     }

或者，我们也可以利用 OrderOpen 函数下达 BUYSTOP 订单。

   if(checkBuy()==true)
     {
      Alert("Total Pending Orders now is :",CountOrders(),"!!");
      //--- any opened Buy position?
      if(Buy_opened)
        {
         Alert("We already have a Buy position!!!");
         return;    //--- Don't open a new Sell Position
        }
      //Buy price = bar 1 High + 2 pip + spread
      int sprd=mysymbol.Spread();
      double bprice =mrate[1].high + 10*_Point + sprd*_Point;
      double mprice=NormalizeDouble(bprice,_Digits);               //--- Buy price
      double stloss = NormalizeDouble(bprice - STP*_Point,_Digits); //--- Stop Loss
      double tprofit = NormalizeDouble(bprice+ TKP*_Point,_Digits); //--- Take Profit
      //--- open BuyStop order
      //if(mytrade.BuyStop(Lot,mprice,_Symbol,stloss,tprofit))
      if(mytrade.OrderOpen(_Symbol,ORDER_TYPE_BUY_STOP,Lot,0.0,bprice,stloss,tprofit,ORDER_TIME_GTC,0)) 
        {
         //--- Request is completed or order placed
         Alert("A BuyStop order has been successfully placed with Ticket#:",mytrade.ResultOrder(),"!!");
         return;
        }
      else
        {
         Alert("The BuyStop order request at vol:",mytrade.RequestVolume(), 
              ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(),
              ", price:", mytrade.RequestPrice(), 
                " could not be completed -error:",mytrade.ResultRetcodeDescription());
         return;
        }
     }

下达 BUYSTOP 订单后，开盘价即为柱 1最高价 + 2pip + 点差。

记住：图表上显示的价格是卖价，而在下达多头/买入订单的过程中，您会需要买价。正因为如此，我们决定在柱 1 最高价的基础上加上点差；所以，现在我们得到的是相应的买价加 2pip 。止损价与获利价已于输入参数中定义。

准备好所有必要参数后，我们利用 CTrade 类函数 BuyStop 或 OrderOpen 来下达订单。此处的订单类型为 ORDER_TYPE_BUY_STOP （买入止损订单）。我们使用与限价相同的价格，但其并非 BuyLimit 订单。我们还将订单有效时间设置为 ORDER_TIME_GTC （意味着订单被取消之前始终有效）。

如果您利用 ORDER_TIME_GTC 或 ORDER_TIME_DAY，则无需指定到期时间，所以我们将到期时间设置为 0。

   if(checkSell()==true)
     {
      Alert("Total Pending Orders now is :",CountOrders(),"!!");
      //--- any opened Sell position?
      if(Sell_opened)
        {
         Alert("We already have a Sell position!!!");
         return;    //--- Wait for a new bar
        }
      //--- Sell price = bar 1 Low - 2 pip 
      double sprice=mrate[1].low-10*_Point;
      double slprice=NormalizeDouble(sprice,_Digits);            //--- Sell price
      double ssloss=NormalizeDouble(sprice+STP*_Point,_Digits);   //--- Stop Loss
      double stprofit=NormalizeDouble(sprice-TKP*_Point,_Digits); //--- Take Profit
      //--- Open SellStop Order
      if(mytrade.SellStop(Lot,slprice,_Symbol,ssloss,stprofit))
      //if(mytrade.OrderOpen(_Symbol,ORDER_TYPE_SELL_STOP,Lot,0.0,slprice,ssloss,stprofit,ORDER_TIME_GTC,0)) 
        {
         //--- Request is completed or order placed
         Alert("A SellStop order has been successfully placed with Ticket#:",mytrade.ResultOrder(),"!!");
         return;
        }
      else
        {
         Alert("The SellStop order request at Vol:",mytrade.RequestVolume(), 
              ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(), 
                ", price:", mytrade.RequestPrice(), 
                " could not be completed -error:",mytrade.ResultRetcodeDescription());
         return;
        }
     }

或者，我们也可以利用 OrderOpen 函数下达订单：

   if(checkSell()==true)
     {
      Alert("Total Pending Orders now is :",CountOrders(),"!!");
      //--- any opened Sell position?
      if(Sell_opened)
        {
         Alert("We already have a Sell position!!!");
         return;    //--- Wait for a new bar
        }
      //--- Sell price = bar 1 Low - 2 pip 
      double sprice=mrate[1].low-10*_Point;
      double slprice=NormalizeDouble(sprice,_Digits);            //--- Sell price
      double ssloss=NormalizeDouble(sprice+STP*_Point,_Digits);   //--- Stop Loss
      double stprofit=NormalizeDouble(sprice-TKP*_Point,_Digits); //--- Take Profit
      //--- Open SellStop Order
      //if(mytrade.SellStop(Lot,slprice,_Symbol,ssloss,stprofit))
      if(mytrade.OrderOpen(_Symbol,ORDER_TYPE_SELL_STOP,Lot,0.0,slprice,ssloss,stprofit,ORDER_TIME_GTC,0)) 
        {
         //--- Request is completed or order placed
         Alert("A SellStop order has been successfully placed with Ticket#:",mytrade.ResultOrder(),"!!");
         return;
        }
      else
        {
         Alert("The SellStop order request at Vol:",mytrade.RequestVolume(), 
                ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(), 
                ", price:", mytrade.RequestPrice(), 
              " could not be completed -error:",mytrade.ResultRetcodeDescription());
         return;
        }
     }

就像 BuyStop 订单一样，开盘价为柱 1最低价 + 2 pip。这里我们无需加上点差，因为一般来讲，我们都需要卖价来下达空头/卖出订单。

我们还利用相同的 OrderOpen 函数或 SellStop 函数来下达 SellStop 订单。此处的订单类型为 ORDER_TYPE_SELL_STOP （卖出止损订单）。

下面即为我们简易“EA 交易”的结果。

图 8. 挂单 EA 的测试报告

图 9 - EA 图形报表

图 10 - EA 图表报告

2.3 获取订单/交易详情

我们会在本示例中阐明，如何在订单被触发后获取其相关详情。

在此阶段，它不再是一个挂单了，因为它已被触发且已转化为一个交易。

为了全面地理解这一流程，我们查看一下某个交易的日志详情：

图 11. 订单处理流程

• 步骤 1： 挂单已下达，等待条件被满足（挂单）。
• 步骤 2： 条件已满足，挂单被触发，变成一个交易（挂单现存于记录中）。
• 步骤 3： 交易被执行，我们得到一个已建仓位。（交易现存于记录中）

2.3.1 获取订单属性（记录）

//+------------------------------------------------------------------+
//|  Include ALL classes that will be used                           |
//+------------------------------------------------------------------+
//--- The Trade Class
#include <Trade\HistoryOrderInfo.mqh>
//+------------------------------------------------------------------+
//|  CREATE CLASS OBJECT                                             |
//+------------------------------------------------------------------+
//--- The HistoryOrderInfo Class Object
CHistoryOrderInfo myhistory;
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- Get all orders in History and get their details
   int buystop=0;
   int sellstop=0;
   int buylimit=0;
   int selllimit=0;
   int buystoplimit=0;
   int sellstoplimit=0;
   int buy=0;
   int sell=0;

   int s_started=0;
   int s_placed=0;
   int s_cancelled=0;
   int s_partial=0;
   int s_filled=0;
   int s_rejected=0;
   int s_expired=0;

   ulong o_ticket;
// Get all history records
   if(HistorySelect(0,TimeCurrent())) // get all history orders
     {
      // Get total orders in history
      for(int j=HistoryOrdersTotal(); j>0; j--)
        {
         // select order by ticket
         o_ticket=HistoryOrderGetTicket(j);
         if(o_ticket>0)
           {
            // Set order Ticket to work with
            myhistory.Ticket(o_ticket);
            Print("Order index ",j," Order Ticket is: ",myhistory.Ticket()," !");
            Print("Order index ",j," Order Setup Time is: ",TimeToString(myhistory.TimeSetup())," !");
            Print("Order index ",j," Order Open Price is: ",myhistory.PriceOpen()," !");
            Print("Order index ",j," Order Symbol is: ",myhistory.Symbol() ," !");
            Print("Order index ",j," Order Type is: ", myhistory.Type() ," !");
            Print("Order index ",j," Order Type Description is: ",myhistory.TypeDescription()," !");
            Print("Order index ",j," Order Magic is: ",myhistory.Magic()," !");
            Print("Order index ",j," Order Time Done is: ",myhistory.TimeDone()," !");
            Print("Order index ",j," Order Initial Volume is: ",myhistory.VolumeInitial()," !");
            //
            //
            if(myhistory.Type() == ORDER_TYPE_BUY_STOP) buystop++;
            if(myhistory.Type() == ORDER_TYPE_SELL_STOP) sellstop++;
            if(myhistory.Type() == ORDER_TYPE_BUY) buy++;
            if(myhistory.Type() == ORDER_TYPE_SELL) sell++;
            if(myhistory.Type() == ORDER_TYPE_BUY_LIMIT) buylimit++;
            if(myhistory.Type() == ORDER_TYPE_SELL_LIMIT) selllimit++;
            if(myhistory.Type() == ORDER_TYPE_BUY_STOP_LIMIT) buystoplimit++;
            if(myhistory.Type() == ORDER_TYPE_SELL_STOP_LIMIT) sellstoplimit++;

            if(myhistory.State() == ORDER_STATE_STARTED) s_started++;
            if(myhistory.State() == ORDER_STATE_PLACED) s_placed++;
            if(myhistory.State() == ORDER_STATE_CANCELED) s_cancelled++;
            if(myhistory.State() == ORDER_STATE_PARTIAL) s_partial++;
            if(myhistory.State() == ORDER_STATE_FILLED) s_filled++;
            if(myhistory.State() == ORDER_STATE_REJECTED) s_rejected++;
            if(myhistory.State() == ORDER_STATE_EXPIRED) s_expired++;
           }
        }
     }
// Print summary
   Print("Buy Stop Pending Orders : ",buystop);
   Print("Sell Stop Pending Orders: ",sellstop);
   Print("Buy Orders : ",buy);
   Print("Sell Orders: ",sell);
   Print("Total Orders in History is :",HistoryOrdersTotal()," !");
   
   Print("Orders type summary");
   Print("Market Buy Orders: ",buy);
   Print("Market Sell Orders: ",sell);
   Print("Pending Buy Stop: ",buystop);
   Print("Pending Sell Stop: ",sellstop);
   Print("Pending Buy Limit: ",buylimit);
   Print("Pending Sell Limit: ",selllimit);
   Print("Pending Buy Stop Limit: ",buystoplimit);
   Print("Pending Sell Stop Limit: ",sellstoplimit);
   Print("Total orders:",HistoryOrdersTotal()," !");

   Print("Orders state summary");
   Print("Checked, but not yet accepted by broker: ",s_started);
   Print("Accepted: ",s_placed);
   Print("Canceled by client: ",s_cancelled);
   Print("Partially executed: ",s_partial);
   Print("Fully executed: ",s_filled);
   Print("Rejected: ",s_rejected);
   Print("Expired: ",s_expired);
  }

这只是一个简单的脚本，旨在说明如何于历史记录中获取订单详情。我们纳入了 CHistoryOrderInfo 类，并创建了一个该类的对象。

现在我们就用这个对象来获取订单详情。

 图 12. 历史订单脚本结果

2.3.2 获取交易属性（记录）

//+------------------------------------------------------------------+
//|  Include ALL classes that will be used                           |
//+------------------------------------------------------------------+
//--- The CDealInfo Class
#include <Trade\DealInfo.mqh>
//+------------------------------------------------------------------+
//|  Create class object                                             |
//+------------------------------------------------------------------+
//--- The CDealInfo Class Object
CDealInfo mydeal;
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- Get all deals in History and get their details
    int buy=0;
    int sell=0;
    int deal_in=0;
    int deal_out=0;
    ulong d_ticket;
    // Get all history records
    if (HistorySelect(0,TimeCurrent())) 
    {
      // Get total deals in history
      for (int j=HistoryDealsTotal(); j>0; j--)
      {
         // select deals by ticket
         if (d_ticket = HistoryDealGetTicket(j))
         {
          // Set Deal Ticket to work with
          mydeal.Ticket(d_ticket);
          Print("Deal index ", j ," Deal Ticket is: ", mydeal.Ticket() ," !");
          Print("Deal index ", j ," Deal Execution Time is: ", TimeToString(mydeal.Time()) ," !");
          Print("Deal index ", j ," Deal Price is: ", mydeal.Price() ," !");
          Print("Deal index ", j ," Deal Symbol is: ", mydeal.Symbol() ," !");
          Print("Deal index ", j ," Deal Type Description is: ", mydeal.TypeDescription() ," !");
          Print("Deal index ", j ," Deal Magic is: ", mydeal.Magic() ," !");
          Print("Deal index ", j ," Deal Time is: ", mydeal.Time() ," !");
          Print("Deal index ", j ," Deal Initial Volume is: ", mydeal.Volume() ," !");
          Print("Deal index ", j ," Deal Entry Type Description is: ", mydeal.EntryDescription() ," !");
          Print("Deal index ", j ," Deal Profit is: ", mydeal.Profit() ," !");
          //
          if (mydeal.Entry() == DEAL_ENTRY_IN) deal_in++;
          if (mydeal.Entry() == DEAL_ENTRY_OUT) deal_out++;
          if (mydeal.Type() == DEAL_TYPE_BUY) buy++;
          if (mydeal.Type() == DEAL_TYPE_SELL) sell++;
         }
      }
    }
    // Print Summary
    Print("Total Deals in History is :", HistoryDealsTotal(), " !");
    Print("Total Deal Entry IN is : ", deal_in);
    Print("Total Deal Entry OUT is: ", deal_out);
    Print("Total Buy Deal is : ", buy);
    Print("Total Sell Deal is: ", sell);
  }

这也是一个简单的脚本，旨在说明如何获取交易记录的详情。

图 13. 历史交易脚本结果

总结

在本文中，我们共同探讨了标准交易类库的主要函数，还对一些编写“EA 交易”会用到的部分功能做了演示说明，这些功能负责实施仓位修改、挂单下达与删除以及交易进行之前对预付款的验证。

我们还演示了可以如何使用它们来获取订单与交易详情。还有一些函数，我们在编写“EA 交易”的过程中并未用到。鉴于采用的交易策略，您将用到的函数可能比本例中用的多、也可能少。

建议您重温一下各个函数的描述部分，看看在编写自己的“EA 交易”时可以怎样利用它们。

标准类库旨在方便交易者与开发人员，所以您一定要用。