MQL5'te emir yerleştirme

Giriş

Herhangi bir alım-satım sisteminde, pozisyon açma, Zararı Durdur ve Kar Al yerleştirme ve emirleri değiştirme gibi emirlerle uğraşmak zorundayız. Bu nedenle, MetaTrader 5 için bir alım-satım sistemi oluştururken MQL5'te emirlerin nasıl yönetileceğini anlamak çok önemlidir. Bu makalenin amacı, çoğu emir ve pozisyon operasyonu için basit bir kılavuz sağlamaktır. Bu makalede aşağıdaki konuları ele alacağız:

• Emirler, işlemler ve pozisyonlar
• OrderSend()
• OrderSend() uygulaması
• CTrade sınıfı
• CTrade sınıfı uygulaması
• Sonuç

Bu makalenin, MetaTrader 5 alım-satım sisteminizi emir yerleştirme açısından sorunsuz bir şekilde geliştirmenize yardımcı olacağını umuyorum. Karlı ve alım-satım tarzınıza uygun olduklarından emin olmak için bu makaledeki tüm uygulamaları kullanmadan önce test edin. Temel amaçları, emirler, işlemler ve pozisyonlarla çalışmak için iki farklı yöntem kullanarak bir alım-satım sisteminin nasıl oluşturulacağına dair bir örnek sağlamaktır.

Sorumluluk reddi: Sağlanan tüm bilgiler 'olduğu gibi' yalnızca bilgilendirme amaçlıdır, alım-satım tavsiyesi değildir. Bu bilgiler herhangi bir sonucu garanti etmemektedir. Bu materyalleri herhangi bir işlem hesabında kullanırsanız, ortaya çıkabilecek tüm riskler size ait olacaktır.

Emirler, işlemler ve pozisyonlar

Bu bölümde, emirlerle nasıl etkili bir şekilde çalışılacağını anlamak için önemli terimlerden bahsedeceğiz. MetaTrader 5'te emirlerle ilgili üç terim arasındaki farka bakacağız. Bu terimler emir, işlem ve pozisyondur. Bu terimleri bir alım-satım işlemini gerçekleştirmenin adımları olarak düşünebiliriz.

Emir: Belirli bir fiyattan belirli bir hacimde bir alış veya satış işlemi açmak için işlem sunucusu tarafından alınan bir taleptir. Piyasa emri ve bekleyen emir olmak üzere iki tür emir vardır.

• Piyasa emri: Mevcut piyasa fiyatından hemen gerçekleştirilebilir bir emirdir.
• Bekleyen emir: İşlemin gerçekleştirileceği fiyat ve zaman ile ilgili önceden belirlenmiş koşullarda işlemi gerçekleştiren bir emirdir. 

Bekleyen emirler aşağıdaki türlerden oluşur:

• Buy Stop: Mevcut piyasa fiyatından daha yüksek olan belirli bir fiyattan alış için bir bekleyen emridir.
• Buy Limit: Mevcut piyasa fiyatından daha düşük olan belirli bir fiyattan alış için bir bekleyen emirdir.
• Sell Stop: Mevcut piyasa fiyatından daha düşük olan belirli bir fiyattan satış için bir bekleyen emirdir.
• Sell Limit: Mevcut piyasa fiyatından daha yüksek olan belirli bir fiyattan satış için bir bekleyen emirdir.

Bir emir yerleştirildiğinde, ister piyasa ister bekleyen emir olsun, MetaTrader 5'teki Araç Kutusunun “İşlem” sekmesinden bulunabilir. Aşağıda bir örnek verilmiştir.

Bir emir gerçekleştirilmeden kapatıldığında veya iptal edildiğinde, Araç Kutusunun “Geçmiş” sekmesinden bulunabilir.

MQL5 ile mevcut bir pozisyonu değiştirmek istediğimizde, bu emirlerle daha sonra emir değiştirmeyi ele alırken göreceğimiz gibi ilgilenmemiz gerekir.

İşlem (deal): Bir emrin yerine getirilmesinin sonucudur. Bunlar, pozisyona giriş (in) ve pozisyondan çıkış (out) eylemleridir. 1 lotluk alış emrinin gerçekleştiğini varsayalım. Sonrasında 0.5 lotluk pozisyonun bir kısmını kapattık, ardından kalan 0.5 lotu kapattık. İşlem (deal) sırası aşağıdaki gibi olacaktır:

• 1 buy in
• 0.5 sell out
• 0.5 sell out

Araç Kutusunun “Geçmiş” sekmesinde sağ tıklayıp işlemlerin gösterilmesini seçerek işlemleri görüntüleyebiliriz.

Pozisyon: Finansal varlığın alış veya satışına dayalı işlemlerin toplamıdır. Aktif pozisyonları “İşlem” sekmesinden veya kapanmış pozisyonları görüntülenmelerini seçerek “Geçmiş” sekmesinden bulabiliriz.

Bir alış emrinin gerçekleştirilebilir fiyatı Ask fiyatıdır ve kapanıştaki gerçekleştirilebilir fiyat Bid fiyatıdır. Öte yandan, bir satış emrinin gerçekleştirilebilir fiyatı Bid fiyatıdır ve kapanıştaki gerçekleştirilebilir fiyat Ask fiyatıdır.

OrderSend()

MetaTrader 5'te işlem gerçekleştirme ile ilgili önemli terimleri inceledikten sonra, MQL5'te emirlerin nasıl otomatik olarak gerçekleştirileceğini öğrenelim. Daha fazla bilgi için MQL5 dokümantasyonundaki “İşlem Fonksiyonları” bölümünü okuyabilirsiniz.

İşlem sunucusuna talepler göndererek alım-satım işlemlerini gerçekleştirmek için kullanılabilen OrderSend() fonksiyonuna bakacağız. Başka bir deyişle, emir yerleştirmek, değiştirmek ve kapatmak için kullanılabilir.

Bu fonksiyonun formatı aşağıda gösterilmiştir:

bool  OrderSend(
   MqlTradeRequest&  request,      
   MqlTradeResult&   result        
   );

Gördüğümüz gibi, fonksiyonun iki parametresi vardır:

• MqlTradeRequest yapısı: Emir parametrelerini ve işlemleri gerçekleştirmek için gerekli tüm değişkenleri içerir. Nesneler referans olarak iletilir. TradeRequest, emirlerin gerçekleştirilmesi için müşteri terminali ile işlem sunucusu arasında bir etkileşim metodudur.
• MqlTradeResult yapısı: TradeResult, bir emir talebinin sonuçlarını geri döndürür. Nesneler referans olarak iletilir.

MqlTradeRequest yapısı:

Bir yapı, farklı türlerde ilişkili veriler kümesidir. MqlTradeRequest yapısının tanımı şu şekildedir:

struct MqlTradeRequest
  {
   ENUM_TRADE_REQUEST_ACTIONS    action;           // Trade operation type
   ulong                         magic;            // Expert Advisor ID (magic number)
   ulong                         order;            // Order ticket
   string                        symbol;           // Trade symbol
   double                        volume;           // Requested volume for a deal in lots
   double                        price;            // Price
   double                        stoplimit;        // StopLimit level of the order
   double                        sl;               // Stop Loss level of the order
   double                        tp;               // Take Profit level of the order
   ulong                         deviation;        // Maximal possible deviation from the requested price
   ENUM_ORDER_TYPE               type;             // Order type
   ENUM_ORDER_TYPE_FILLING       type_filling;     // Order execution type
   ENUM_ORDER_TYPE_TIME          type_time;        // Order expiration type
   datetime                      expiration;       // Order expiration time (for the orders of ORDER_TIME_SPECIFIED type)
   string                        comment;          // Order comment
   ulong                         position;         // Position ticket
   ulong                         position_by;      // The ticket of an opposite position
  };

Aşağıdaki kod satırını kullanarak bir MqlTradeRequest nesnesi bildirebiliriz:

MqlTradeRequest request;

Ardından, aşağıdaki örnekte gösterildiği gibi, nesneden sonra bir nokta (.) ekleyerek oluşturulan request nesnesinin değişkenlerine işlem parametrelerini atayabiliriz:

request.symbol = _Symbol;
request.volume = 0.01;
request.type = ORDER_TYPE_BUY;

Aşağıda, MqlTradeRequest yapısının tüm değişkenlerinin ve bu değişkenlere atanabilecek değerlerin bir listesi bulunmaktadır.

Değişken	Açıklama	Atanabilecek değer
action	Alım-satım işlemi türü	ENUM_TRADE_REQUEST_ACTIONS numaralandırmasından biri (TRADE_ACTION_DEAL, TRADE_ACTION_PENDING, TRADE_ACTION_SLTP, TRADE_ACTION_MODIFY, TRADE_ACTION_REMOVE, TRADE_ACTION_CLOSE_BY)
magic	Belirli bir Uzman Danışman tarafından yerleştirilen emirleri tanımlamak için Uzman Danışman kimliği	ulong türünde değer
order	Emir fişi. action değişkeninde TRADE_ACTION_MODIFY veya TRADE_ACTION_REMOVE kullanıldığında gereklidir	ulong türünde değer
symbol	İşlemin yapılacağı sembol. (_SYMBOL) mevcut sembolü ifade eder	string türünde sembol
volume	İşlem hacmi (lot)	double türünde değer
price	İşlemin gerçekleştirilmesi istenen fiyat	double türünde değer
stoplimit	Bekleyen Stop Limit emrin yerleştirileceği fiyat. action değişkeni TRADE_ACTION_PENDING olmalı ve type değişkeni ORDER_TYPE_BUY_STOP_LIMIT veya ORDER_TYPE_SELL_STOP_LIMIT olmalıdır. Bu değişken Stop Limit emirleri için gereklidir	double türünde değer
sl	İşlemin Zararı Durdur fiyatı	double türünde değer
tp	İşlemin Kar Al fiyatı	double türünde değer
deviation	Puan cinsinden maksimum fiyat sapması	ulong türünde değer
type	Emir türü	ENUM_ORDER_TYPE numaralandırmasından biri (ORDER_TYPE_BUY, ORDER_TYPE_SELL, ORDER_TYPE_BUY_STOP, ORDER_TYPE_SELL_STOP,  ORDER_TYPE_BUY_LIMIT, ORDER_TYPE_SELL_LIMIT,  ORDER_TYPE_BUY_STOP_LIMIT, ORDER_TYPE_SELL_STOP_LIMIT)
type_filling	Emir yerine getirme türü	ENUM_ORDER_TYPE_FILLING numaralandırmasından biri (ORDER_FILLING_FOK, ORDER_FILLING_IOC, ORDER_FILLING_BOC, ORDER_FILLING_RETURN)
type_time	Bekleyen emrin sona erme zamanı türü	ENUM_ORDER_TYPE_TIME sıralamasından biri (ORDER_TIME_GTC, ORDER_TIME_DAY, ORDER_TIME_SPECIFIED, ORDER_TIME_SPECIFIED_DAY)
expiration	Bekleyen emrin sona erme zamanı. type_time değeri ORDER_TIME_SPECIFIED değerine eşitse gereklidir	datetime türünde değer
comment	Emir yorumu	string türünde değer
position	Pozisyon fişi. Bir pozisyonu değiştirirken veya kapatırken tanımlamak için gereklidir	ulong türünde değer
position_by	Zıt pozisyon fişi. Aynı sembol için zıt pozisyonun kapatılmasında kullanılır	ulong türünde değer

Şimdi MQL5'te emir yerleştirilirken kullanılması gereken bazı önemli alım-satım işlemlerine göz atalım.

• Piyasa emri
• Zararı Durdur ve Kar Al ekleme
• Bekleyen emir
• Bekleyen emri değiştirme
• Bekleyen emri silme

Piyasa emri:

Bir piyasa emri vermek istiyorsak, bu, emrin mevcut piyasa fiyatından yerleştirileceği anlamına gelir. Bu işlem türü için, action değişkeni olarak TRADE_ACTION_DEAL kullanılmalıdır. Bu bir alış emri ise, mevcut Ask fiyatından veya bir satış emri ise, mevcut Bid fiyatından yerleştirilecektir. İşte nasıl yapılacağı: 

MqlTradeRequest ve MqlTradeResult nesnelerini bildirdikten sonra, değişkenlere aşağıdaki değerleri atayabiliriz:

request.action = TRADE_ACTION_DEAL;                    &nbsthe p;   //market order palcement
request.type = ORDER_TYPE_BUY;                             //type of order is buy
request.symbol = _Symbol;                                  //applied for the cuurrent symbol
request.volume = 0.1;                                      //the lot size
request.type_filling = ORDER_FILLING_FOK;                  //the filling policy fill or kill
request.price = SymbolInfoDouble(_Symbol,SYMBOL_ASK);      //the price is the current ask for buy
request.sl = 0;                                            //stop loss is 0
request.tp = 0;                                            //take profit is 0
request.deviation = 50;                                    //slippage is 50
OrderSend(request, result);                                //calling the OrderSend function

Gördüğümüz gibi, Zararı Durdur ve Kar Al değerlerini eklemedik. Değerlerini diğer değişkenlerle birlikte koda ekleyebilir veya bir sonraki kısımda gösterildiği gibi başka bir alım-satım işlemi kullanarak ekleyebiliriz.

Zararı Durdur ve Kar Al ekleme:

Zararı Durdur ve Kar Al eklememiz gerektiğinde, aşağıdaki örnekte gösterildiği gibi action değişkenine TRADE_ACTION_SLTP atarız.

request.action = TRADE_ACTION_SLTP;          //adding sl and tp
request.symbol = _Symbol;                    //applied for the cuurrent symbol
request.sl = 1.07000;                        //sl price
request.sl = 1.09000;                        //tp price
OrderSend(request, result);                  //calling the OrderSend function

Bekleyen emir:

Bir bekleyen emir yerleştirmek istiyorsak, başka bir action (TRADE_ACTION_PENDING) kullanabiliriz. Daha sonra emir türünü tanımlarız. Bekleyen emir için bir sona erme zamanına ihtiyacımız varsa zamanı ayarlayabiliriz.

request.action = TRADE_ACTION_PENDING;          //pending order placement
request.type = ORDER_TYPE_BUY_STOP;             //type of order is buy stop
request.symbol = _Symbol;                       //applied for the cuurrent symbol
request.volume = 0.1;                           //the lot size
request.price = 1.07000;                        //opening price
request.sl = 1.06950;                           //stop loss
request.tp = 1.07100;                           //take profit
request.type_time = ORDER_TIME_SPECIFIED;       //to set an expiration time
request.expiration = D'2023.08.31 00.00';       //expiration time - datetime constant          
request.type_filling = ORDER_FILLING_FOK;       //the filling policy fill or kill
request.stoplimit = 0;                          //for stoplimit order only
OrderSend(request, result);                     //calling the OrderSend function

Bekleyen emri değiştirme:

Bir bekleyen emri değiştirirken, emrin fiş numarasına ihtiyacımız var. Emir fişini edinmek için OrderGetTicket fonksiyonunu kullanabiliriz. Bu fonksiyon, ilgili emrin fişini geri döndürür, bu sayede emri seçebilir ve onunla çalışabiliriz.

ulong  OrderGetTicket( 
   int  index      // Number in the list of orders 
   );

Bir emir fişi içeren bir değişkenimiz (ticket) olduğunu varsayalım. Bu değişkeni, emir fişini request nesnesinin order değişkenine atamak için kullanabiliriz. Daha sonra aşağıdaki örnekte olduğu gibi TRADE_ACTION_MODIFY action değişkenini kullanarak emri değiştirebiliriz.

request.action = TRADE_ACTION_MODIFY;           //pending order modyfying
request.order = ticket;                         //ticket variable that holds the pending order ticket to modify
request.price = 1.07050;                        //new opening price
request.sl = 1.07000;                           //new stop loss
request.tp = 1.07150;                           //new take profit
request.type_time = ORDER_TIME_SPECIFIED;       //to set an expiration time
request.expiration = D'2023.09.01 00.00';       //new expiration time - datetime constant        
OrderSend(request, result);                     //calling the OrderSend function

Bekleyen emri silme:

Bir bekleyen emri silmemiz gerekiyorsa, bunu TRADE_ACTION_REMOVE kullanarak yapabiliriz. Silmeyi istediğimiz bekleyen emrin fiş numarasına da ihtiyacımız olacaktır. Gerekli fiş numarasını içeren bir değişken (bizim durumumuzda ticket) kullanabiliriz.

request.action = TRADE_ACTION_REMOVE;           //pending order remove
request.order = ticket;                         //ticket variable that holds the pending order ticket to remove
OrderSend(request, result);                     //calling the OrderSend function

MqlTradeResult yapısı:

MqlTradeResult yapısı, OrderSend() fonksiyonu tarafından emir yerleştirme talebi gönderildikten sonra emrin başarıyla yerleşip yerleşmediğinin sonucunu geri döndürür. Fiş numarası, hacim ve fiyat gibi işlem sunucusundan gelen bilgileri içerir.

Aşağıda MqlTradeResult yapısının tanımı yer almaktadır:

struct MqlTradeResult
  {
   uint     retcode;          // Operation return code
   ulong    deal;             // Deal ticket, if it is performed
   ulong    order;            // Order ticket, if it is placed
   double   volume;           // Deal volume, confirmed by broker
   double   price;            // Deal price, confirmed by broker
   double   bid;              // Current Bid price
   double   ask;              // Current Ask price
   string   comment;          // Broker comment to operation (by default it is filled by description of trade server return code)
   uint     request_id;       // Request ID set by the terminal during the dispatch 
   int      retcode_external; // Return code of an external trading system
  };

result adında bir nesne bildirebilir ve OrderSend() fonksiyonunu çağırırken ilk parametreden (request) sonra ikinci parametre olarak iletebiliriz.

MqlTradeResult result;

MqlTradeResult yapısındaki değişkenlerden de görebileceğimiz gibi, retcode değişkeni çok önemlidir çünkü talebin başarılı olup olmadığını belirtmek için işlem sunucusundan bir kod geri döndürür.

Emir yerleştirilmemişse, geri dönen kod bir hata durumunu belirtir. Daha fazla bilgi için MQL5 dokümantasyonundan geri dönüş kodları listesine bakabilirsiniz. Aşağıdaki örnekte gösterildiği gibi, alım-satım sistemimize bir hatanın geri döndürülüp döndürülmediğini raporlayan bir kod eklemek son derece önemlidir:

   if(result.retcode == TRADE_RETCODE_DONE || result.retcode == TRADE_RETCODE_PLACED)
     {
      Print("Trade Placed Successfully");
     }
   else
     {
      Print("Trade Not Placed, Error ", result.retcode);
     }

Gördüğümüz gibi, emir başarıyla yerleştirildiyse, bize bununla ilgili bir mesaj gönderecek veya bir sorun varsa, sorunu çözmeye yardımcı olacak hata koduyla birlikte bir hata olduğuna dair bir mesaj yazdıracaktır.

OrderSend() uygulaması

OrderSend() fonksiyonunu kullanarak işlem gerçekleştirebilen basit bir alım-satım sistemi oluşturmamız gerekiyor. Oluşturacağımız alım-satım sistemi Simple Moving Average çaprazlamasına dayanacak ve işlem türü yalnızca piyasa emri olacaktır.

Buradaki amaç, OrderSend() ve CTrade sınıfını kullanarak aynı alım-satım sistemini oluştururken ortaya çıkan farkları anlamaktır. Aşağıda OrderSend() fonksiyonunu kullanarak bir MA çaprazlaması sistemi oluşturma adımları yer almaktadır.

Global kapsamda değer atamadan iki tamsayı değişken (simpleMA ve barTotal) oluşturalım. Değer ataması daha sonra OnInit() içinde yapılacaktır.

int simpleMA;
int barsTotal;

SimpleMA, hareketli ortalama teknik göstergesinin tanıtıcısını geri döndüren “iMA” fonksiyonuna atanacaktır. Parametreleri şunlardır:

• symbol - Sembol adı. Mevcut sembole uygulanmak üzere (_Symbol) kullanacağız.
• period - Zaman dilimi. H1 zaman dilimine uygulanmak üzere (PERIOD_H1) kullanacağız.
• ma_period - Hareketli ortalama periyodu. (50) ayarlayacağız.
• ma_shift - Hareketli ortalama kayma miktarı. (0) ayarlayacağız.
• ma_method - Moving Average yöntemi. Simple Moving Average (MODE_SMA) kullanacağız.
• applied_price - Hesaplamada kullanılan fiyat türü. Kapanış fiyatını (PRICE_CLOSE) kullanacağız.

BarsTotal, çubuk sayısını geri döndüren “iBars” fonksiyonuna atanacaktır. Parametreleri şunlardır:

• symbol - Sembol adı. Mevcut sembole uygulanmak üzere (_Symbol) kullanacağız.
• timeframe - Zaman dilimi. H1 zaman dilimine uygulanmak üzere (PERIOD_H1) kullanacağız.

   simpleMA = iMA(_Symbol, PERIOD_H1, 50, 0, MODE_SMA, PRICE_CLOSE);
   barsTotal=iBars(_Symbol,PERIOD_H1);

OnTick() içinde iki dizi oluşturacağız: fiyat, hacim ve makas bilgilerini depolayan MqlRates türünde priceArray (fiyatlar için) ve double türünde mySMAArray (SMA değerleri için).

   MqlRates priceArray[];
   double mySMAArray[];

Ask ve Bid fiyatlarını tanımlayalım.

   double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);
   double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);

OrderSend() için biri MqlTradeRequest kullanarak request ve diğeri MqlTradeResult kullanarak result olmak üzere iki nesne oluşturalım ve ardından request değişkenini referans olarak sıfırlayalım.

ZeroMemory(request);

“ArraySetAsSeries” fonksiyonunu kullanarak priceArray ve mySMAArray dizilerini mevcut veriden başlayarak sıralayalım. Parametreleri şunlardır:

• array[] - Sıralamanın yapılacağı dizi.
• flag - Dizi indeksleme yönü. (true) ayarlayacağız.

   ArraySetAsSeries(priceArray,true);
   ArraySetAsSeries(mySMAArray,true);

“CopyRates” fonksiyonunu kullanılarak MqlRates'in geçmiş verilerini alalım. Parametreleri şunlardır:

• symbol - Sembol adı. Mevcut sembol için (_Symbol) kullanacağız.
• timeframe - Zaman dilimi. Mevcut zaman dilimi için (_Period) kullanacağız.
• start_pos - Kopyalamanın başlangıç konumu. Mevcut konumdan başlaması için (0) ayarlayacağız.
• count - Kopyalanacak veri miktarı. (3) ayarlayacağız.
• rates_array[] - Kopyalamanın yapılacağı hedef dizi. (priceArray) dizisini kullanacağız.

int Data=CopyRates(_Symbol,_Period,0,3,priceArray);

“CopyBuffer” fonksiyonunu kullanarak hareketli ortalama göstergesinin arabellek verilerini alalım. Parametreleri şunlardır:

• indicator_handle - Gösterge tanıtıcısı. (simpleMA) kullanacağız.
• buffer_num - Gösterge arabellek numarası. (0) ayarlayacağız.
• start_pos - Kopyalamanın başlangıç konumu. (0) ayarlayacağız.
• count - Kopyalanacak veri miktarı. (3) ayarlayacağız.
• buffer[] - Kopyalamanın yapılacağı hedef dizi. (mySMAArray) dizisini kullanacağız.

CopyBuffer(simpleMA,0,0,3,mySMAArray);

Son kapanış fiyatını, önceki kapanış fiyatını, son SMA değerini ve önceki SMA değerini tanımlayalım.

   double lastClose=(priceArray[1].close);
   double prevClose=(priceArray[2].close);
   double SMAVal = NormalizeDouble(mySMAArray[1],_Digits);
   double prevSMAVal = NormalizeDouble(mySMAArray[2],_Digits);

bars adında bir tamsayı değişken oluşturalım ve bunu “iBars” fonksiyonuna atayalım.

int bars=iBars(_Symbol,PERIOD_H1);

barsTotal ve bars değerlerinin eşit olup olmadığını kontrol edelim.

if(barsTotal != bars)

Birbirlerine eşit değillerse barsTotal değerini bars değerine eşit olacak şekilde güncelleyelim.

barsTotal=bars;

Bir alış işlemi açmak için strateji koşulunu kontrol edelim: önceki kapanış fiyatı önceki SMA değerinden düşükse ve aynı zamanda son kapanış fiyatı son SMA değerinden yüksekse.

if(prevClose<prevSMAVal && lastClose>SMAVal)

MqlTradeRequest fonksiyonuyla ilişkili uygun değişkenleri kullanarak bir piyasa alış emri açalım.

         request.action = TRADE_ACTION_DEAL;
         request.type = ORDER_TYPE_BUY;
         request.symbol = _Symbol;
         request.volume = 0.1;
         request.type_filling = ORDER_FILLING_FOK;
         request.price = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
         request.sl = Ask-(500*_Point);
         request.tp = Ask+(1000*_Point);
         request.deviation = 50;
         OrderSend(request, result);

Bir satış işlemi açmak için strateji koşulunu kontrol edelim: önceki kapanış fiyatı önceki SMA değerinden yüksekse ve aynı zamanda son kapanış fiyatı son SMA değerinden düşükse.

if(prevClose>prevSMAVal && lastClose<SMAVal)

MqlTradeRequest fonksiyonuyla ilişkili uygun değişkenleri kullanarak bir piyasa satış emri açalım.

         request.type = ORDER_TYPE_SELL;
         request.symbol = _Symbol;
         request.volume = 0.1;
         request.type_filling = ORDER_FILLING_FOK;
         request.price = SymbolInfoDouble(_Symbol,SYMBOL_BID);
         request.sl = Bid+(500*_Point);
         request.tp = Bid-(1000*_Point);
         request.deviation = 50;
         OrderSend(request, result);

Aşağıda, OrderSend() fonksiyonunu kullanarak bu bir alım-satım sistemini oluşturmaya yönelik tam kod yer almaktadır.

//+------------------------------------------------------------------+
//|                                     OrderSend_Trading_system.mq5 |
//+------------------------------------------------------------------+
int simpleMA;
int barsTotal;
int OnInit()
  {
   simpleMA = iMA(_Symbol, PERIOD_H1, 50, 0, MODE_SMA, PRICE_CLOSE);
   barsTotal=iBars(_Symbol,PERIOD_H1);
   return(INIT_SUCCEEDED);
  }
void OnTick()
  {
   MqlRates priceArray[];
   double mySMAArray[];
   double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);
   double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);
   MqlTradeRequest request;
   MqlTradeResult result;
   ZeroMemory(request);
   ArraySetAsSeries(priceArray,true);
   ArraySetAsSeries(mySMAArray,true);
   int Data=CopyRates(_Symbol,_Period,0,3,priceArray);
   CopyBuffer(simpleMA,0,0,3,mySMAArray);
   double lastClose=(priceArray[1].close);
   double prevClose=(priceArray[2].close);
   double SMAVal = NormalizeDouble(mySMAArray[1],_Digits);
   double prevSMAVal = NormalizeDouble(mySMAArray[2],_Digits);
   int bars=iBars(_Symbol,PERIOD_H1);
   if(barsTotal != bars)
     {
      barsTotal=bars;
      if(prevClose<prevSMAVal && lastClose>SMAVal)
        {
         request.action = TRADE_ACTION_DEAL;
         request.type = ORDER_TYPE_BUY;
         request.symbol = _Symbol;
         request.volume = 0.1;
         request.type_filling = ORDER_FILLING_FOK;
         request.price = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
         request.sl = Ask-(500*_Point);
         request.tp = Ask+(1000*_Point);
         request.deviation = 50;
         OrderSend(request, result);
        }
      if(prevClose>prevSMAVal && lastClose<SMAVal)
        {
         request.action = TRADE_ACTION_DEAL;
         request.type = ORDER_TYPE_SELL;
         request.symbol = _Symbol;
         request.volume = 0.1;
         request.type_filling = ORDER_FILLING_FOK;
         request.price = SymbolInfoDouble(_Symbol,SYMBOL_BID);
         request.sl = Bid+(500*_Point);
         request.tp = Bid-(1000*_Point);
         request.deviation = 50;
         OrderSend(request, result);
        }
     }
  }

CTrade sınıfı

OrderSend() fonksiyonunu kullanarak nasıl emir yerleştirileceğini öğrendik, ancak alım-satım fonksiyonlarına erişmenin kolay bir yolu var. MQL5 tarafından sağlanan hazır CTrade sınıfını kullanabilir veya kişisel tercihlerimiz için kendi sınıfımızı oluşturabiliriz. Şimdi, hazır CTrade sınıfını MQL5'te nasıl kullanabileceğimizden bahsedeceğiz. Daha fazla bilgiyi MQL5 dokümantasyonunun CTrade sınıfı bölümünde bulabilirsiniz.

İlk olarak, CTrade sınıfı eklenti dosyasını MetaTrader 5 kurulum dosyalarının include klasörünün Trade klasöründe bulabiliriz. İhtiyacımız olan tek şey, aşağıda açıklandığı gibi tüm alım-satım fonksiyonlarını çağırmak ve kullanmak için bu dosyayı Uzman Danışmana dahil etmektir:

#include <Trade\Trade.mqh>

CTrade sınıfından bir nesne oluşturalım.

CTrade trade;

Sonrasında, CTrade sınıfındaki tüm alım-satım fonksiyonlarını, trade nesnesinin yanına nokta (.) ve istenen fonksiyonu ekleyerek kullanabiliriz. Emirlerle çalışma, pozisyonlarla çalışma, son request parametrelerine erişim, son request kontrol sonuçlarına erişim, son request gerçekleştirme sonuçlarına erişim gibi tüm fonksiyonları kullanabiliriz.

İki metot arasındaki farkları anlamak için OrderSend() metodunda yaptığımız gibi bazı önemli fonksiyonlardan bahsedeceğiz. Şimdi aşağıdakilerin nasıl yapılacağını görelim:

• Piyasa emri
• Zararı Durdur ve Kar Al ekleme
• Bekleyen emir
• Bekleyen emri değiştirme
• Bekleyen emri silme

Piyasa emri:

trade nesnemizi oluşturduktan sonra, bir piyasa emri yerleştirmek için PositionOpen fonksiyonunu kullanabiliriz.

• symbol - Sembol adı.
• order_type - Pozisyon açmak için emir türü.
• volume - Lot büyüklüğü.
• price - Pozisyonun açılış fiyatı.
• sl - Zararı Durdur fiyatı.
• tp - Kar Al fiyatı.
• comment - Yorum veya NULL.

Aşağıda bir örnek verilmiştir:

trade.PositionOpen(
   _Symbol,             //to be applied for the current symbol
   ORDER_TYPE_BUY,      //to place buy order
   0.1,                 //lot size or volume
   Ask,                 //opening price of the order - current ask
   Ask-(500*_Point),    //sl
   Ask+(1000*_Point),   //tp
   NULL                 //NULL
);

Bir piyasa emri açmak için, CTrade'de PositionOpen yerine Buy veya Sell gibi ek metotlar da kullanabiliriz.

Zararı Durdur ve Kar Al ekleme:

PositionModify fonksiyonunu kullanarak pozisyonu sembol veya fiş numarasına göre değiştirebiliriz. Parametreleri şunlardır:

• symbol or ticket - pozisyonu sembole göre değiştirirken sembol, fişe göre değiştirirken fiş numarası.
• sl - Yeni Zarar Durdur fiyatı.
• tp - Yeni Kar Al fiyatı.

Sembol ile değiştirme örneği:

trade.PositionModify(
   EURUSD,       //the symbol name
   1.06950,      //the new sl
   1.07100,      //the new tp
);

Fiş ile değiştirme örneği:

trade.PositionModify(
   ticket,       //the ticket variable that holds the needed ticket number to modify
   1.06950,      //the new sl
   1.07100,      //the new tp
);

Bekleyen emir:

CTrade sınıfını kullanarak bir bekleyen emir yerleştirmemiz gerekiyorsa, OrderOpen fonksiyonunu kullanabiliriz. Parametreleri şunlardır:

• symbol - Sembol adı.
• order_type - Bekleyen emir türü.
• volume - Lot büyüklüğü.
• limit_price - Stop Limit fiyatı.
• price - Bekleyen emrin gerçekleşme fiyatı.
• sl - Zararı Durdur fiyatı.
• tp - Kar Al fiyatı.
• type_time - Sona erme zamanı türü.
• expiration - Sona erme zamanı.
• comment - Yorum.

Aşağıdaki örnekte OrderOpen fonksiyonu kullanılarak bir Buy Limit bekleyen emrinin yerleştirilmesi gösterilmektedir.

         trade.OrderOpen(
            "EURUSD",                 // symbol
            ORDER_TYPE_BUY_LIMIT,     // order type
            0.1,                      // order volume
            0,                        // StopLimit price
            1.07000,                  // execution price
            1.06950,                  // Stop Loss price
            1.07100,                  // Take Profit price
            ORDER_TIME_SPECIFIED,     // type by expiration
            D'2023.08.31 00.00',      // expiration
            ""                        // comment
         );

Bekleyen emri değiştirme:

Yerleştirilmiş bir bekleyen emri değiştirmemiz gerekiyorsa, bunu CTrade sınıfını OrderModify fonksiyonu ile kullanarak yapabiliriz. Parametreleri şunlardır:

• ticket - Değiştirilecek bekleyen emrin fişi.
• fiyat - Yeni gerçekleştirme fiyatı.
• sl - Yeni Zarar Durdur fiyatı.
• tp - Yeni Kar Al fiyatı.
• type_time - Yeni sona erme zamanı türü.
• expiration - Yeni sona erme zamanı.
• stoplimit - Yeni Stop Limit fiyatı.

Aşağıda bir bekleyen emrin değiştirilmesine ilişkin bir örnek verilmiştir.

         trade.OrderModify(
            ticket,                   // ticket number of the pending order to modify
            1.07050,                  // execution price
            1.07000,                  // Stop Loss price
            1.07150,                  // Take Profit price
            ORDER_TIME_SPECIFIED,     // type by expiration
            D'2023.08.31 00.00',      // expiration
            0,                        // StopLimit price
         );

Bekleyen emri silme:

Bir bekleyen emri silmemiz gerekiyorsa, bunu OrderDelete fonksiyonunu kullanarak yapabiliriz. Bekleyen emrin fiş numarası silme için gereklidir. Aşağıda bu fonksiyona bir örnek verilmiştir.

         trade.OrderDelete(
            ticket,                 // tick number of the pending order to delete
         );

CTrade sınıfı uygulaması

OrderSend() ile oluşturduğumuz alım-satım sisteminin aynısını oluşturalım. Fonksiyonların çalışma şeklindeki farklılıkları anlamak için CTrade sınıfını kullanacağız.

Aşağıda, CTrade sınıfını kullanarak bir alım-satım sistemi oluşturmak için yalnızca farklı adımlar bulunmaktadır. Geri kalan adımlar yukarıda anlatılanlarla aynıdır.

Trade include dosyasını #include önişlemcisini kullanarak dahil edelim.

#include <Trade\Trade.mqh>

CTrade sınıfından bir trade nesnesi oluşturalım.

CTrade trade;

Alış koşulu karşılandığında, PositionOpen kullanırız. Emir türü ORDER_TYPE_BUY veya aşağıdaki kodda olduğu gibi ek Buy metodu olacaktır.

trade.Buy(0.1,_Symbol,Ask,Ask-(500*_Point),Ask+(1000*_Point),NULL);

Satış koşulu karşılandığında, PositionOpen kullanırız. Emir türü ORDER_TYPE_SELL veya aşağıdaki kodda olduğu gibi ek Sell metodu olacaktır.

trade.Sell(0.1,_Symbol,Bid,Bid+(500*_Point),Bid-(1000*_Point),NULL);

Aşağıda, CTrade sınıfını kullanarak bir alım-satım sistemi oluşturmaya yönelik kodun tamamı yer almaktadır:

//+------------------------------------------------------------------+
//|                                        CTrade_Trading_System.mq5 |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
int simpleMA;
int barsTotal;
CTrade trade;
int OnInit()
  {
   simpleMA = iMA(_Symbol, PERIOD_H1, 50, 0, MODE_SMA, PRICE_CLOSE);
   barsTotal=iBars(_Symbol,PERIOD_H1);
   return(INIT_SUCCEEDED);
  }
void OnTick()
  {
   MqlRates priceArray[];
   double mySMAArray[];
   double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);
   double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);
   ArraySetAsSeries(priceArray,true);
   ArraySetAsSeries(mySMAArray,true);
   int Data=CopyRates(_Symbol,_Period,0,3,priceArray);
   CopyBuffer(simpleMA,0,0,3,mySMAArray);
   double lastClose=(priceArray[1].close);
   double prevClose=(priceArray[2].close);
   double SMAVal = NormalizeDouble(mySMAArray[1],_Digits);
   double prevSMAVal = NormalizeDouble(mySMAArray[2],_Digits);
   int bars=iBars(_Symbol,PERIOD_H1);
   if(barsTotal != bars)
     {
      barsTotal=bars;
      if(prevClose<prevSMAVal && lastClose>SMAVal)
        {
         trade.Buy(0.1,_Symbol,Ask,Ask-(500*_Point),Ask+(1000*_Point),NULL);
        }
      if(prevClose>prevSMAVal && lastClose<SMAVal)
        {
         trade.Sell(0.1,_Symbol,Bid,Bid+(500*_Point),Bid-(1000*_Point),NULL);
        }
     }
  }

Sonuç

MQL5'te emirlerin, işlemlerin ve pozisyonların nasıl çalıştığına baktık ve ayrıca iki alım-satım metodunu kullanarak bir alım-satım sisteminin nasıl oluşturulacağını gördük - OrderSend() fonksiyonu ve CTrade sınıfı.

Bu iki metodu kullanarak piyasa ve bekleyen emirlerin nasıl yerleştirileceğini, Zarar Durdur ve Kar Al emirlerinin nasıl ekleneceğini, bekleyen emirlerin nasıl değiştirileceğini ve silineceğini de öğrendik.

İki metodu kullanarak aynı hareketli ortalama çaprazlaması alım-satım sistemini oluşturmak için iki basit uygulamayı da inceledik.

• OpenSend_Trading_System
• CTrade_Trading_System

Bahsedilen uygulamaların amacı yalnızca aralarındaki farkları uygulamalı olarak anlamanızı sağlamaktır, bu nedenle lütfen şu konuda dikkatli olun: karlı ve alım-satım tarzınıza uygun olduklarından emin olmak için bunları herhangi bir gerçek hesapta kullanmadan önce test etmelisiniz.

Alım-satım işlemleri ile çalışırken hazır CTrade sınıfını kullanmanın kolaylığını takdir ettiğinizi varsayıyorum. Genel olarak programlamadaki diğer sınıf özelliklerinin yanı sıra, çok fazla zaman ve emek tasarrufu sağlar.

MQL5'te nesne yönelimli programlama hakkında daha fazla bilgi edinmek istiyorsanız, “MQL5’te Nesne Yönelimli Programlama (Object-Oriented Programming, OOP)” başlıklı önceki makalemi okuyabilirsiniz. Umarım sizin için faydalı olur. MQL5, alım-satım uygulamalarının kolay ve verimli bir şekilde geliştirilmesi ve oluşturulması için gerekli araçları sağlar.

Umarım bu makale sizin için yararlı olur ve alım-satım hedeflerinize ulaşmanıza katkıda bulunur. Profilimin Yayınlar bölümünden, en popüler teknik göstergelere dayalı alım-satım sistemleri oluşturma konusundaki makalelerimi bulabilirsiniz. Umarım bunlar da sizin için faydalı olur.