Expert Advisor yazarken MQL5 Standard Alım Satım Sınıfı kitaplıklarının kullanımı

Samuel Olowoyo | 15 Aralık, 2021

Giriş

Yeni MQL5 programı, yatırımcılar ve geliştiriciler için MQL5 Expert Advisor'larının, Göstergelerin ve Script Dosyalarının geliştirilmesini mümkün olduğunca kolaylaştırmayı amaçlayan birçok yerleşik Standart sınıf kitaplığı ile birlikte gelir.

Bu sınıf kitaplıkları, MetaTrader 5 istemci terminali klasöründeki MQL5 klasöründe bulunan \Include\ klasöründe bulunur. Sınıf kitaplıkları çeşitli kategorilere ayrılmıştır – Diziler, ChartObjects, Grafikler, Dosyalar, Göstergeler, Dizeler ve Alım Satım sınıfları.

Bu makalede, bir Expert Advisor yazmak için yerleşik Alım Satım sınıflarını nasıl kullanabileceğimizi ayrıntılı olarak açıklayacağız. Expert Advisor, öngörülen bir koşul karşılandığında açılan pozisyonların kapatılmasını ve değiştirilmesini içerecek bir stratejiye dayanacaktır.

Sınıfların ne olduğu ve nasıl kullanılabileceği konusunda zaten bir fikriniz varsa yeni MQL5 dilinin sunduğu başka bir fırsat dünyasına hoş geldiniz.

Diğer yandan, MQL5'te tamamen yeniyseniz o zaman başlangıç için Yeni Başlayanlar için MQL5'te Expert Advisor Yazmak için Adım Adım Kılavuz, MQL5 Nesne Yönelimli Programlama Yaklaşımını Kullanarak Expert Advisor Yazma başlıklı bu iki makaleyi veya size yeni MQL5 diline giriş sağlayacak başka herhangi bir makaleyi okumanızı öneririm. Size gerekli bilgiyi verecek çok sayıda makale yazılmıştır.

1. Alım Satım Sınıfları

Alım satım sınıfları klasörü, kişisel kullanım için bir EA geliştirecek olan yatırımcılar veya Expert Advisor'larını (EA) geliştirirken tekerleği yeniden icat etmek zorunda kalmayacak programcılar için hayatı kolaylaştırmayı amaçlayan farklı sınıflardan oluşur.

Bir sınıfı kullanırken, sınıfın iç işleyişini (yani, geliştiricinin söylediği şeyi nasıl başardığını) bilmek zorunda değilsiniz; odaklanmanız gereken tek şey, sorununuzu çözmek için sınıfın nasıl kullanılabileceğidir. Bu nedenle, yerleşik bir sınıf kitaplığı kullanmak, bunları kullanmak isteyen herkes için işleri oldukça kolaylaştırır. Bu yazıda, bir Expert Advisor geliştirme sürecinde ihtiyaç duyulacak ana sınıfları gözden geçireceğiz.

Sınıfları tartışırken, sınıfların dahili ayrıntılarıyla kafamızı karıştırmayacağız, ancak sınıfın neler yapabileceğini ve çok karlı bir EA geliştirme misyonumuzu gerçekleştirmek için onu nasıl kullanabileceğimizi ayrıntılı olarak ele alacağız. Bunları birer birer tartışalım.

1.1 The СAccountInfo Sınıf

CAccountInfo, kullanıcının istemci terminalinde halihazırda açılmış olan alım satım hesabı için tüm hesap özelliklerine veya bilgilerine erişmesini kolaylaştıran bir sınıftır.

Başlamak iyi anlamak için, EA'mızda muhtemelen kullanabileceğimiz bu sınıfın başlıca üye işlevlerini gözden geçireceğiz. Bir sınıfı kullanabilmek için öncelikle o sınıftan bir nesne oluşturmalıyız; dolayısıyla CAccountInfo sınıfını kullanmak için o sınıftan bir nesne oluşturmalıyız.

Bunu myaccount olarak adlandıralım:

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

Bir sınıfın nesnesini oluşturmak için sınıf adını ve ardından nesneye vermek istediğiniz adı kullanacağınızı unutmayın.

Artık, CAccountInfo sınıfının genel üye işlevlerine erişmek için myaccount nesnemizi kullanabiliriz.

// 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 Sınıfı

CSymbolInfo sınıfı, kullanıcının mevcut sembolün tüm özelliklerine hızlı bir şekilde erişmesini fazlasıyla kolaylaştırır.

Sınıfı kullanmak için sınıfın bir nesnesini oluşturmalıyız; bu durumda onu mysymbol olarak adlandıracağız.

// the CSymbolInfo Class object
CSymbolInfo mysymbol;

 Bu sınıfın Expert Advisor'ımızı yazma sürecinde kullanılabilecek işlevlerinin çoğunu gözden geçirelim:

// 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 Sınıfı

CHistoryOrderInfo, talimat geçmişi özelliklerini yönetmeyi fazlasıyla kolaylaştıran başka bir sınıftır.

Bu sınıfın bir nesnesini oluşturduktan sonra, acil bir sorunu çözmek için ihtiyaç duyduğumuz önemli genel üye işlevlerine erişmek için nesneyi kullanabiliriz.

myhistory sınıfının nesnesini adlandıralım.

// The CHistoryOrderInfo Class object
CHistoryOrderInfo myhistory;

Bu sınıfın bazı ana işlevlerini gözden geçirelim.

Geçmişteki talimatların ayrıntılarını elde etmek için bu sınıfı kullanırken, öncelikle geçmişteki toplam talimatları elde etmemiz ve ardından talimat biletini myhistory sınıf nesnemize iletmemiz gerekir.

//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(); 

Şimdi mevcut toplam geçmiş talimatlarını yineleyeceğiz ve sınıf nesnemizle her geçmiş talimatın ayrıntılarını elde edeceğiz.

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();

Bu işlevleri geçmişteki toplam talimat döngüsü içinde kullandığımızı unutmayın.

1.4 СOrderInfo Sınıfı

Bu COrderInfo, bekleyen tüm talimat özelliklerine kolay erişim sağlayan bir sınıftır. Bu sınıfın bir nesnesi oluşturulduktan sonra, bu sınıfın genel üye işlevleri için kullanılabilir.

Bu sınıfın kullanımı, yukarıda tartışılan CHistoryOrderInfo sınıfına kısmen benzerdir.

Sınıfın bir nesnesini oluşturalım; bunu myorder olarak adlandıracağız.

// The OrderInfo Class object
COrderInfo myorder;

Bekleyen bir talimatın ayrıntılarını elde etmek için bu sınıfı kullanabilmek için, öncelikle mevcut toplam talimatları elde etmemiz ve ardından bunları talimat biletine göre seçmemiz gerekir.

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

Toplam talimatlar arasında gezineceğiz ve oluşturduğumuz nesneyi kullanarak bunlara karşılık gelen özelliklerini elde edeceğiz.

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 Sınıfı

CDealInfo sınıfı, yatırım özelliklerinin veya bilgilerinin tüm geçmişine erişim sağlar.  Bu sınıfın bir nesnesini oluşturduktan sonra, onu CHistoryOrderInfo sınıfına benzer bir şekilde, geçmişteki yatırımlar hakkında her bilgiyi elde etmek için kullanacağız.

Dolayısıyla, yapmak istediğimiz ilk şey, bu sınıfın bir nesnesini oluşturmak ve onu mydeal olarak adlandırmaktır.

// The DealInfo Class object
CDealInfo myinfo; 

Geçmişteki toplam yatırımları elde ederek başlayacağız

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

Şimdi mevcut toplam geçmiş talimatlarını yineleyeceğiz ve sınıf nesnemizle her geçmiş talimatın ayrıntılarını elde edeceğiz.

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 Sınıfı

CPositionInfo sınıfı, mevcut pozisyon özelliklerine kolay erişim sağlar. Pozisyon özelliklerini elde etmek için kullanabilmek için bu sınıfın bir nesnesini oluşturmalıyız.

Bu sınıfın bir nesnesini oluşturalım ve bunu myposition olarak adlandıralım.

// The object of the CPositionInfo class
CPositionInfo myposition;

Artık açık pozisyon ayrıntılarını elde etmek için bu nesneyi kullanacağız. Mevcut toplam açık pozisyonları elde ederek başlayacağız:

int pos_total = PositionsTotal();

Şimdi tüm açık pozisyonları gözden geçirme ve ayrıntılarını elde etme zamanı.

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 Sınıfı

CTrade sınıfı, MQL5'teki alım satım işlemlerine kolay erişim sağlar. Bu sınıfı kullanmak için sınıfın bir nesnesini oluşturmalı ve daha sonra onu gerekli alım satım işlemlerini gerçekleştirmek için kullanmalıyız.

Bu sınıfın bir nesnesini oluşturacağız ve bunu mytrade olarak adlandıracağız:

//An object of the CTrade class
CTrade mytrade;

İlk adım, nesnenin alım satım işlemi yaparken kullanacağı parametrelerin çoğunu ayarlamaktır.

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()); 

Alım Satım Sınıfı Talebi işlevleri, talimat vermeyle ilgili hataları belirlerken çok kullanışlıdır. Talimat verirken bazı hata mesajları aldığımız zamanlar oluyor ve neyin yanlış gittiğini hemen tespit edemediğimizde bu biraz kafa karıştırıcı oluyor. Alım Satım Sınıfı talebi işlevlerini kullanarak, alım satım sunucusuna gönderilen bazı talep parametrelerimizi yazdırarak neyi yanlış yaptığımızı tespit edebiliriz. Bu tür kullanıma bir örnek aşağıdaki koda benzer olacaktır:

 //--- 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;
           }

Yukarıdaki kodda, bir hata olması durumunda talebimizde gönderilen parametrelerin bir kısmını tespit edebilmeye çalıştık. Örneğin, doğru Zararı Durdur fiyatını belirtmemişsek, Geçersiz Durdurma hatası alabiliriz ve mytrade.RequestSL() işlevini kullanarak Zararı Durdur değerini yazdırarak belirtilen Zararı Durdur fiyatımızla ilgili sorunun ne olduğunu bilebileceğiz.

Sınıfların her birinin nasıl kullanılabileceğini göstermek için zaman ayırdık; şimdi tanımladığımız bazı işlevleri pratiğe dönüştürme zamanı.

Lütfen Expert Advisor'da kullanacağımız tüm işlevlerin yukarıda halihazırda açıklandığını unutmayın; yazacağımız kodlarda herhangi bir işlevi gördüğünüzde her zaman açıklamalara başvurmanız sizin açınızdan iyi olacaktır. 

2. Alım Satım Sınıflarının işlevlerini kullanma

Bu alım satım sınıflarının işlevlerinin nasıl kullanılacağını göstermek için aşağıdaki görevleri gerçekleştirecek bir Expert Advisor yazacağız.

• Al veya Sat koşulunu kontrol edecek ve koşul karşılanırsa, karşılanan koşula bağlı olarak bir Al veya Sat talimatı verecektir.
• Bir pozisyon açıldıysa ve alım satım işlemi bizim yönümüzde ilerlemeye devam ederse, pozisyonun kar al veya zararı durdur ayarını değiştireceğiz. Ancak, alım satım işlemi aleyhimizdeyse ve kar hedefimize ulaşılmamışsa pozisyonu kapatacağız.
• EA'mız, şu para birimlerinden herhangi birinde günlük grafikte alım satım işlemi yapmak için kullanılacaktır – GBPUSD, AUDUSD, EURUSD, vb.

2.1 Expert Advisor'ı Yazma

Başlamak için yeni bir MQL5 belgesi başlatın ve Expert Advisor (şablon) öğesini seçin ve İleri düğmesine tıklayın:

Şekil 1. Yeni bir MQL5 belgesi başlatma

Expert Advisor'ın adını yazın ve Bitir düğmesine tıklayın. Giriş parametrelerini daha sonra manuel olarak tanımlayacağız.

Şekil 2. Expert Advisor'ı Adlandırma

Oluşturulan yeni belge aşağıdakine benzer şekilde görünmelidir.

#property sürüm satırından hemen sonra, kullanacağımız tüm Alım Satım sınıflarını dahil edeceğiz.

//+------------------------------------------------------------------+
//|  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>

Ardından giriş parametrelerimizi tanımlayacağız:

//+------------------------------------------------------------------+
//|  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

Bu Expert Advisor kodunda kullanılacak diğer parametreleri de belirteceğiz:

//+------------------------------------------------------------------+
//|  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

Şimdi eklediğimiz sınıfların her birinin bir nesnesini oluşturalım:

//+------------------------------------------------------------------+
//|  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;

Şimdi yapmak istediğimiz bir sonraki şey, işimizi fazlasıyla kolaylaştırmak için kullanacağımız bazı işlevleri tanımlamak.

Bu işlevleri tanımladıktan sonra, onları OnInit() ve OnTick() işlevlerinde gerekli bölümlerde çağıracağız.

2.1.1 checkTrading işlevi

Bu işlev, Expert Advisor'ımızın alım satım işlemi yapıp yapamayacağını görmek için tüm ilk kontrolleri gerçekleştirmek için kullanılacaktır. Bu işlev true değerini döndürürse, EA'mız devam edecek; aksi takdirde EA herhangi bir alım satım işlemi yapmayacaktır.

//+------------------------------------------------------------------+
//|  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 bool veri türünü bildirdik ve onu false yaptık. Alım satım işlemine izin verilip verilmediğini ve ayrıca Expert Advisor'ların bu hesapta alım satım yapmasına izin verilip verilmediğini kontrol etmek için CAccountInfo sınıfının nesnesini kullandık. Ayrıca terminalin alım satım sunucusuyla senkronize olup olmadığını kontrol etmek için CSymbolInfo sınıfının bir nesnesini kullanırız.

Bu üç koşul karşılandıktan sonra, mevcut çubukların toplam sayısının EA'mızın alım satım işlemi yapması için gereken minimum çubuklardan büyük olup zamanı. Bu işlev true değerini döndürürse, EA'mız alım satım etkinliklerinde bulunacaktır; aksi takdirde EA'mız bu işlevdeki koşullar karşılanana kadar herhangi bir alım satım etkinliğinde bulunmayacaktır.

Gördüğünüz gibi, standart alım satım sınıfı kitaplıklarının gerekli nesnelerini kullanarak gerekli tüm alım satım kontrol etkinliklerini bu işleve dahil etmeye karar verdik.

2.1.2 ConfirmMargin işlevi

//+------------------------------------------------------------------+
//|  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 sınıfın nesnesini, bir talimat vermek için hesabımızın serbest marjının yalnızca belirli bir yüzdesini kullanacağımız ayarına dayalı olarak alım satım yapmak için yeterli marj olup olmadığını doğrulamak için kullanırız.

Hesabın serbest marjının gerekli yüzdesi, talimat için gerekli marjdan büyükse bu işlev true değerini döndürür; aksi takdirde false değerini döndürür.  Bununla, yalnızca işlev true değerini döndürürse bir talimat vermek isteriz. Bu işlev, giriş parametresi olarak talimat türünü alır.

2.1.3 CheckBuy işlevi

//+------------------------------------------------------------------+
//|  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);
}

Bu işlevde alış işlemi açma koşullarını tamamlamaya karar verdik. Burada Sınıf nesnesi işlevlerinin hiçbirini kullanmadık. Hareketli Ortalama göstergesinin değerlerinin yukarı doğru arttığı ve önceki çubuğun kapanış fiyatının o noktadaki Hareketli ortalama değerinden yüksek olduğu durumu kontrol ediyoruz.

Ayrıca, ADX göstergesinin değerinin giriş parametrelerinde gerekli minimum ayardan büyük olduğu ve ADX göstergesinin pozitif DI değerinin negatif DI değerinden büyük olduğu bir durum istiyoruz. Bu koşullar karşılandığında, EA'mızın bir SATIN ALMA talimatı açmasını isteyeceğiz.

2.1.4 CheckSell işlevi

//+------------------------------------------------------------------+
//|  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);
} 

Bu işlev, CheckBuy işlevinin tam tersini kontrol eder. Ayrıca bu işlevde herhangi bir sınıf nesnesi kullanmadık. Bu işlev, Hareketli Ortalama göstergesinin değerlerinin aşağı doğru düştüğü ve önceki çubuğun kapanış fiyatının o noktadaki Hareketli ortalama değerinden düşük olduğu bir durumu kontrol eder.

Yalnızca ADX göstergesinin değerinin giriş parametrelerinde gerekli minimum ayardan büyük olduğu ve ADX göstergesinin negatif DI değerinin pozitif DI değerinden büyük olduğu bir durum istiyoruz. Bu koşullar karşılandığında, EA'mızın bir SATIŞ talimatı açmasını isteyeceğiz.

//+------------------------------------------------------------------+
//|  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);
}

Bu işlev, mevcut açık pozisyonun kapatılıp kapatılamayacağını kontrol etmek için kullanılır. Bu işlev, bir önceki çubuğun kapanış fiyatının o noktadaki Hareketli Ortalama göstergesinin değerinden daha yüksek veya daha düşük olup olmadığını (alım satım işlemi yönüne bağlı olarak) izlemek için kullanılır.

Koşullardan herhangi biri karşılanırsa bu işlev true değerini döndürür; bunun ardından EA'mızın pozisyonu kapatmasını bekleyeceğiz. Bu işlevin iki giriş parametresi vardır; talimat türü (bu kez adı SATIN ALMA veya SATIŞ) ve önceki çubuğun kapanış fiyatı.

2.1.6 ClosePosition işlevi

//+------------------------------------------------------------------+
//| 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);
     }

Bu, aslında yukarıdaki işlevi kullanan işlevdir (checkclosepos). Bu, CPositionInfo ve CTrade sınıflarının nesnelerini kullanır. Bu işlev, EA'mız tarafından açılan pozisyon ve mevcut sembol için mevcut açık pozisyonları kontrol etmek için CPositionInfo sınıfının nesnesini kullanır. Herhangi bir pozisyon bulunursa checkclosepos işlevini kullanarak kapatılıp kapatılamayacağını kontrol eder.

checkclosepos işlevi true değerini döndürürse bu işlev pozisyonu kapatmak için CTrade sınıfının nesnesini kullanır ve pozisyon kapatma işlemi için sonuçları görüntüler. Pozisyon başarıyla kapatıldıysa bu işlev true değerini döndürür; aksi taktirde false değerini döndürür.

İşlev iki giriş parametresi alır (pozisyon adı , ALIŞ veya SATIŞ ve önceki çubuğun kapanış fiyatı). Bu parametreler aslında onları kullanan checkclosepos işlevine iletildi.

2.1.7 CheckModify işlevi

//+------------------------------------------------------------------+
//|  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);
} 

Bu işlev, mevcut açık pozisyonun değiştirilip değiştirilemeyeceğini onaylayan bir koşulu kontrol etmek için kullanılır. Herhangi parametreleri olarak talimat türü adını ve önceki çubuğun kapanış fiyatını kullanır.

Bu işlevin yaptığı şey, Hareketli ortalamanın hala yukarı doğru artıp artmadığını ve önceki çubuğun kapanış fiyatının o noktadaki Hareketli ortalama değerinden hala yüksek olup olmadığını ve ADX değerinin de gerekli minimum değerden büyük olup olmadığını kontrol etmek iken (bir SATIN ALMA pozisyonu) Hareketli ortalamanın hala aşağı doğru düşüp düşmediğini ve önceki çubuğun kapanış fiyatının o noktadaki hareketli ortalamanın değerinden düşük olup olmadığını kontrol etmektir (SATIŞ pozisyonu için). Sahip olduğumuz pozisyonun türüne bağlı olarak, koşullardan herhangi biri karşılanırsa EA pozisyonu değiştirmeyi düşünecektir.

İşlev, yedek giriş parametrelerini alır (pozisyon adı, ALIŞ veya SATIŞ ve önceki çubuğun kapanış fiyatı).

2.1.8 Modify işlevi

//+------------------------------------------------------------------+
//| 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;
        }

     }

 Bu işlev, işini yapmak için yukarıdaki işlevi (checkmodify) kullanır. CSymbolInfo ve CTrade sınıflarının nesnelerini kullanır. İlk olarak, yeni kar al, zararı durdur, teklif fiyatını ve satış fiyatını tutmak için dört adet çift veri türü bildirdik. Daha sonra, giriş parametreleri bölümünde ayarlanan Trail_point değerini tutacak tsp yeni bir uzun veri türü bildirdik.

Bunun ardından takip noktası değeri (tsp) daha sonra 5 ve 3 basamaklı fiyatlar için ayarlandı. Ardından durdurma düzeyini elde etmek için CSymbolInfo nesnesini kullandık ve eklemek istediğimiz takip noktasının gerekli durdurma düzeyinden küçük olmadığından emin olduk. Durdurma düzeyinden küçükse, bu durumda durdurma düzeyi değerini kullanacağız.

Pozisyon türüne bağlı olarak, duruma göre geçerli ALIŞ veya SATIŞ fiyatını elde etmek için CSymbolInfo sınıf nesnesini kullanırız. Mevcut ALIŞ veya SATIŞ fiyatı ile ilk kar al fiyatı arasındaki fark durdurma düzeyinden küçük veya buna eşitse hem zararı durdur hem de kar al fiyatlarını ayarlamaya karar veririz; aksi takdirde yalnızca zararı durdur değerini ayarlarız.

Ardından, pozisyon için Zararı Durdur ve Kar Al'ı değiştirmek için CTrade sınıf nesnesini kullanırız. Alım satım işlemi sonucu dönüş koduna bağlı olarak başarılı veya başarısız olunduğuna ilişkin bir mesaj da görüntülenir.

İşimizi kolaylaştıracak bazı kullanıcı tanımlı işlevleri tanımlamayı bitirdik. Şimdi EA kodları bölümüne geçelim.

2.1.9 OnInit Bölümü

//--- 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 sınıf nesnesi için geçerli sembolü ayarlamaya karar veriyoruz. Ayrıca CTrade sınıf nesnesini kullanarak Expert Advisor sihirli sayısını ve sapmayı (puan olarak) belirledik. Bundan sonra, göstergelerimiz için tanıtıcıları almaya karar veriyoruz; tanıtıcıların alınması başarısız olursa bir hata görüntüleriz.

Ardından, 3 ve 5 basamaklı fiyatlar için zararı durdur ve kar al'ı ayarlamaya karar vererek alım satım için kullanılacak serbest hesap marjı yüzdesini yüzdeye dönüştürürüz.

2.1.10 OnDeinit Kesiti

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

Burada tüm gösterge tanıtıcılarını serbest bırakmaya karar veriyoruz.

2.1.11. OnTick Kesiti

//--- 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);

Burada yaptığımız ilk şey, EA'mızın alım satım yapması gerekip gerekmediğini kontrol etmek ve bundan emin olmaktır. checktrade işlevi false değerini döndürürse EA bir sonraki tick'i bekleyecek ve kontrol işlemini tekrar yapacaktır.

Bundan sonra, her çubuğun fiyatını elde etmek için bir MQL5 MqlRates Yapısı bildirdik, ardından gerekli tüm dizileri ayarlamak için ArraySetAsSeries işlevini kullanıyoruz.

//--- 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]; 

Geçerli fiyat tekliflerini almak için CSymbolInfo sınıf nesnesini kullanırız ve ardından mevcut çubuk fiyatlarını mrates dizisine kopyalarız. Bundan hemen sonra yeni bir çubuğun olup olmadığını kontrol etmeye karar veriyoruz.

Yeni bir çubuğumuz varsa EA'mız bir AL veya SAT koşulunun karşılanıp karşılanmadığını kontrol etmeye devam edecek; aksi takdirde yeni bir çubuğumuz olana kadar bekleyecektir.

//--- 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

Burada, göstergelerimizin arabelleklerini dizilere almak için CopyBuffer işlevlerini kullandık; işlemde hata meydana gelirse görüntülenecektir. Önceki çubuğun kapanış fiyatı kopyalandı.

//--- 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
                 }
             } 
       }
    } 

Geçerli sembol için açık bir pozisyonumuz olup olmadığını seçmek ve kontrol etmek için CPositionInfo sınıf nesnesini kullanırız. Bir pozisyon varsa ve bu bir BUY ise, Buy_opened öğesini true olarak ayarlarız ve daha sonra pozisyonun zararı durdur ve kar al değerini almak için CPositionInfo sınıf kullanılır. Daha önce tanımladığımız ClosePosition işlevini kullanarak pozisyonun kapalı olup olmadığını kontrol ettik. İşlev true değerini döndürürse pozisyon kapatılmış demektir; bu nedenle Buy_opened öğesini false olarak ayarladık, ilk SATIN ALMA pozisyonu henüz kapatılmış oldu. EA şimdi yeni bir tick bekleyecek.

Ancak, işlev false değerini döndürürse pozisyon kapatılmamış demektir. Şimdi pozisyonu değiştirip değiştiremeyeceğimizi kontrol etme zamanı. Bunu daha önce tanımladığımız CheckModify işlevini kullanarak gerçekleştirmiştik. İşlev true değerini döndürürse bu, pozisyonun değiştirilebileceği anlamına gelir; bu nedenle pozisyonu değiştirmek için Modify işlevini kullanırız.

Diğer taraftan, bir pozisyon varsa ve bu SATIŞ ise, Sell_opened true olarak ayarlarız ve pozisyonun zararı durdur ve kar al değerini almak için CPositionInfo sınıf nesnesini kullanırız. SATIN ALMA pozisyonu için yaptığımız işlemin aynısını pozisyonun kapatılıp kapatılamayacağını veya değiştirilip değiştirilemeyeceğini görmek için tekrarladık.

      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;
           }
        }

Veya PositionOpen işlevini kullanabiliriz

      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;
           }
        }

Burada, satın alma kurulumunu kontrol etmek için checkbuy işlevini kullanırız; true değerini döndürürse, o zaman ALIŞ işlemi koşullarımız karşılanmış demektir. Halihazırda bir SATIN ALMA pozisyonumuz varsa yeni bir talimat vermek istemiyoruz. Daha sonra mevcut SATIŞ fiyatını elde etmek için CSymbolInfo sınıf nesnesini kullandık ve Zararı Durdur ve Kar Al'ı gereken şekilde hesapladık.

Ayrıca, hesabın talimat vermek için izin verilen yüzdesinin bu talimatı vermek için gereken marjdan büyük olup olmadığını kontrol etmek için ConfirmMargin işlevini kullanırız. İşlev true değerini döndürürse devam edip alım satımı yaparız; aksi taktirde alım satımı yapmayız.

CTrade sınıf nesnesini kullanarak, talimatımızı verdik ve alım satım işlemi dönüş kodunu elde etmek için aynı çağrılar nesnesini kullandık. Alım satım sonucuna göre bir mesaj görüntülenir.

      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;
           }

        }

Veya PositionOpen işlevini de kullanabiliriz:

      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;
           }
        }

SATIN ALMA için yaptığımız gibi, satış kurulumunu kontrol etmek için Checksell işlevini kullandık. true değerini döndürmesi ve zaten açık bir satış pozisyonumuz olmaması halinde talimatı açmak için yeterli paramız olup olmadığını kontrol etmek için ConfirmMargin işlevini kullandık. ConfirmMargin true değerini döndürürse talimatı vermek için CTrade sınıf nesnesi kullanılır ve alım satım sunucusundan gelen yanıta göre, alım satım işleminin sonucu CTrade sınıf nesnesi işlevleri kullanılarak görüntülenir.

Şimdiye kadar bir Expert Advisor yazarken Alım Satım sınıfı kitaplıklarını nasıl kullanabileceğimizi gözden geçirdik. Sonraki adım , Expert Advisor'ımızı strateji test cihazı ile test etmek ve performansını görmek.

EA kodunu derleyin ve ardından Strateji Test Cihazına yükleyin.

         Şekil 3. Expert Advisor rapor derleme

Şu varsayılan ayarları kullanarak GBPUSD Günlük grafiğinde: Kar Al - 270, Zararı Durdur - 100 ve Takip Noktası (TP/SL) - 32, şu sonuçları elde ederiz:

Şekil 4. Expert Advisor test raporu - GBPUSD günlük grafiği

Şekil 5. Expert Advisor test grafiği sonucu - GBPUSD günlük grafiği

Şekil 6. Expert Advisor test raporu, açık pozisyonlardaki değişiklikleri gösterir - GBPUSD günlük grafiği

Şekil 7.  GBPUSD günlük grafiği için Expert Advisor test grafiği raporu

Kar Al, Zararı Durdur ve Takip noktasının farklı ayarlarıyla EA'yı başka herhangi bir günlük sembol grafiğinde test etmekte özgürsünüz; ne elde edeceğinizi görün. 

Ancak, bu Expert Advisor'ın yalnızca test amacıyla yazıldığını bilmeniz gerekir...

Şimdi talimat/yatırım ayrıntılarını elde etmek için diğer sınıfları (COrderInfo, CHistoryOrderInfo ve CDealInfo) nasıl kullanacağımıza bakalım.

2.2 Bekleyen Bir Talimatı Açma/Silme

Bu örnekte, sırasıyla Alış veya Satış kurulum koşulları sağlandığında bekleyen bir talimat (BuyStop veya SellStop) verecek basit bir Expert Advisor yazacağız.

2.2.1 Gerekli Sınıfları Dahil Etme

//+------------------------------------------------------------------+
//|  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>

Bu basit Expert Advisor'da kullanacağımız dört sınıfı ekledik. Bunlar, yukarıdaki örneklerde açıklanmıştır.

Yukarıda açıklanana benzer olduğu için bu Expert Advisor'ın her bölümünü ele almayacağım, ancak bu bölümde neyi tartışmak istediğimizi açıklayan Expert Advisor'ın temel kısmına değineceğim.

Farklı olan tek şey, genel kapsamda MqlRates mrate[] bildirmeye karar vermiş olmamızdır.

//--- 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

Sınıfları ekledikten sonra, her sınıftan nesneler oluşturmayı da unutmamalıyız:

//+------------------------------------------------------------------+
//|  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() ve CheckSell() işlevleri, daha önce açıklanan Expert Advisor'dakiyle aynıdır.

Burada yapmak istediğimiz, alış kurulumumuz varken BUYSTOP talimatı, satış kurulumumuz varken SELLSTOP talimatı vermektir.

Şimdi işleri bizim için kolaylaştırmak için oluşturduğumuz bazı işlevleri gözden geçirelim.

2.2.2 CountOrders işlevi

//+------------------------------------------------------------------+
//|  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);
  }

Bu işlev, çok kısa bir süre içinde mevcut toplam bekleyen talimatları almak için kullanılır.

myorder.Select() işleviyle başarılı bir şekilde seçilip seçilmediğini talimatın ayrıntılarını kontrol etmek için COrderInfo sınıfımızın nesnesini kullandık.

Sınıf nesnemiz tarafından döndürülen Sihirli Sayı ve döndürülen sembol aradığımız şeyse, bu durumda talimat Expert Advisor'ımız tarafından verilmiştir; bu nedenle sayılır ve mark değişkeninde saklanır.

2.2.3 DeletePending işlevi

//+------------------------------------------------------------------+
//| 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);
  }

Counterorder işlevi gibi , bu işlev de talimat özelliklerini elde etmek için COrderInfo sınıf işlevlerini kullanır . İşlev, üç çubuk önce ayarlanmış bekleyen talimatları kontrol eder (bekleyen talimat kurulum süresi mrate[2].time'dan azdır) ve henüz tetiklenmemiştir.

Herhangi bir talimat o kategoriye girerse talimatı silmek için CTrade sınıf işlevi, OrderDelete öğesini kullanılır. Bu işlev, başarılı olduğunda true, başarısız olduğunda false değerini döndürür.

Yukarıdaki iki işlev , yeni bir çubuk oluşturulduktan hemen sonra, yeni bir alım satım kurulumunu kontrol etmeden önce kullanılır. Zamanın her noktasında üçten fazla bekleyen talimatımız olmadığından emin olmak istiyoruz.  Bunu yapmak için aşağıdaki kodu kullanıyoruz:

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

2.2.4 Bekleyen Bir Talimat Verme

   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;
        }
     }

Veya BUYSTOP talimatını vermek için OrderOpen işlevini de kullanabiliriz

   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 talimatımızı verirken , açılış fiyatı Çubuk 1 Yüksek + 2pip + spread'dir.

Grafikte görüntülenen fiyatın ALIŞ fiyatı olduğunu ve uzun/alış talimatları verirken SATIŞ fiyatına ihtiyacınız olduğunu unutmayın; bu nedenle, şu anda sahip olduğumuz şey olan ilgili Satış fiyatı + 2pip olan Çubuk 1 Yüksek'e spread'i eklemeye karar verdik. Durdurma kaybı ve Kar al, giriş parametrelerinde zaten tanımlanmış.

Gerekli tüm parametreleri hazırladıktan sonra, talimatımızı vermek için CTrade BuyStop veya OrderOpen sınıf işlevini kullanırız. Buradaki Talimat Türü ORDER_TYPE_BUY_STOP öğesidir (Buy-Stop talimatı). Limit fiyat için aynı fiyatı kullanıyoruz ama bu bir BuyLimit talimatı değildir. Ayrıca talimat geçerlilik süresini ORDER_TIME_GTC olarak ayarladık; bu, talimatlar iptal edilene kadar geçerli kalacağı anlamına gelir.

ORDER_TIME_GTC veya ORDER_TIME_DAY kullanırsanız sona erme süresi belirtmenize gerek yoktur; bu nedenle sona erme süresini 0 olarak ayarlıyoruz.

   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;
        }
     }

Veya talimatı vermek için OrderOpen işlevini kullanabiliriz:

   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 talimatında olduğu gibi, açılış fiyatı Çubuk 1 düşük + 2pip'dir. Burada spread eklememize gerek yok; zira normalde kısa/satış talimatları vermek için ALIŞ fiyatına ihtiyacımız var.

SellStop Talimatını vermek için aynı OrderOpen işlevini veya SellStop işlevini de kullanırız. Buradaki talimat türü ORDER_TYPE_SELL_STOP (Sell-Stop talimatı) şeklindedir.

Basit Expert Advisor'ımızın sonuçları aşağıda verilmiştir.

Şekil 8. Bekleyen talimat EA için test raporu

Şekil 9 - EA için grafik raporu

Şekil 10. EA için Grafik raporu

2.3 Talimat/Yatırım Ayrıntılarını Elde Etme

Bu örnekte, tetiklendikten sonra bir talimatın ayrıntılarını nasıl elde edebileceğimizi göstereceğiz.

Bu aşamada, tetiklenip bir yatırıma dönüştürüldüğü için artık bekleyen bir talimat değildir.

Bu prosedürü tam olarak anlamak için alım satım işlemlerimizin birindeki günlük ayrıntılarına bakalım:

Şekil 11. Talimat işleme prosedürü

• Adım 1: Koşulların karşılanması için bekleyen bir talimat verilir (Bekleyen talimat)
• Adım 2: Koşul karşılanır, bekleyen talimat tetiklenir, yatırım haline gelir (Bekleyen talimat artık geçmişte)
• Adım 3: Yatırım gerçekleşir; açık bir pozisyonumuz var. (Yatırım artık geçmişte)

2.3.1 Talimat Özelliklerini Alma (Geçmiş)

//+------------------------------------------------------------------+
//|  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);
  }

Bu, Geçmiş kayıtlarımızdaki talimatların ayrıntılarının nasıl elde edileceğini gösteren basit bir script dosyasıdır. CHistoryOrderInfo sınıfını dahil ettik ve sınıfın bir nesnesini oluşturduk.

Şimdi talimatların ayrıntılarını almak için nesneyi kullanıyoruz.

Şekil 12. Geçmiş talimat script dosyası sonucu

2.3.2 Yatırım Özelliklerini Elde Etme (Geçmiş)

//+------------------------------------------------------------------+
//|  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);
  }

Bu aynı zamanda yatırım kayıtlarımızın ayrıntılarının nasıl elde edileceğini gösteren basit bir script dosyasıdır.

Şekil 13. Geçmiş yatırım script dosyası sonucu

Sonuç

Bu makalede, Standart Alım Satım Sınıfı kitaplıklarının ana işlevlerini gözden geçirdik ve bu işlevlerden bazılarının bir alım satım işlemi yapmadan önce pozisyon değiştirme, bekleyen talimat verme ve Marjı silme ve doğrulama işlemlerini uygulayan Expert Advisor'lar yazarken nasıl kullanılabileceğini gösterdik.

Talimat ve yatırım ayrıntılarını elde etmek için nasıl kullanılabileceğini de gösterdik. Expert Advisor'ımızı yazarken bu işlevlerden bazılarını kullanmayız; kullandığınız alım satım stratejisinin türüne bağlı olarak, bu örnekte kullandığımızdan daha fazlasını veya daha azını kullanabilirsiniz.

Çeşitli işlevler için açıklama bölümünü gözden geçirmek ve kendi Expert Advisor'ımızı yazarken bunlardan nasıl yararlanabileceğinizi görmek iyi bir fikir olacaktır.

Standart sınıf kitaplıkları, hem yatırımcıların hem de geliştiricilerin hayatını kolaylaştırmaya yöneliktir; bu nedenle bunları kullandığınızdan emin olun.