Ana içeriğe geç

cBot kod örnekleri

Bu sayfa, işlem botları oluşturmak ve algoritmalar geliştirmek için çeşitli Python ve C# kod örnekleri sunar. Aşağıda listelenen cBot'ların hiçbiri finansal getiri garanti etmez. Gerçek bir hesapta herhangi bir örnek dağıtmadan önce cBot'larınızı geriye dönük test ettiğinizden ve özelleştirdiğinizden emin olun.

cBot örnek depoları

Çeşitli otomatik stratejiler ve işlem stilleri için hazır şablonlar da dahil olmak üzere kapsamlı cBot kod örnekleri, GitHub'daki ayrı Python ve C# depolarında mevcuttur.

Senkron işlemler

Bu bölümdeki tüm cBot'lar işlemlerini senkron olarak yürütür.

Piyasa emirlerini gerçekleştirme

  • Başarılı işlemler gerçekleştiren basit bir cBot

    Aşağıdaki işlem robotu, başlangıçta bir piyasa emri oluşturur ve sonucu result değişkenine kaydeder.

    Emir gerçekleştirme başarılı olursa, giriş fiyatı günlüğe yazdırılır.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
    [Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        var result = ExecuteMarketOrder(TradeType.Buy, SymbolName, 10000);

        if (result.IsSuccessful)
        {
            var position = result.Position;
            Print("Position entry price is {0}", position.EntryPrice);
        }
    }
}

    1
2
3
4
5
6
7
    class Sample_cBot():
    def on_start(self):
        result = api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, 10000)

        if result.IsSuccessful:
            position = result.Position
            api.Print(f"Position entry price is {position.EntryPrice}")

    Günlük çıktısı

    • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
    • 10000 EURUSD Almak İçin Piyasa Emri Gerçekleştiriliyor
    • 10000 EURUSD Almak İçin Piyasa Emri BAŞARILI, Pozisyon PID14576001
    • Pozisyon giriş fiyatı 1.19067

  • Özelleştirilebilir parametrelere sahip basit bir cBot

    Çeşitli cBot özelliklerini bildirirken, [Parameter()] bildirimini kullanarak onları özelleştirilebilir parametrelere dönüştürebilirsiniz. cBot'unuzun yeni bir örneği başlatıldığında, siz (veya diğer kullanıcılar) bunlara özel değerler atayabileceksiniz.

    Aşağıdaki örneği inceleyin.

    1
2
    [Parameter("SMA Period", DefaultValue = 14)]
public int SmaPeriod { get; set; }

    Not

    Python cBot'ları, .cs dosyalarında bildirilen özelleştirilebilir parametreler kullanır.

    1
2
    [Parameter("SMA Period", DefaultValue = 14)]
public int SmaPeriod { get; set; }

    Yukarıdaki örnekte, aşağıdaki özellikleri tanımlıyoruz:

    • Parametrenin adı. Daha sonra cTrader kullanıcı arayüzünde ("SMA Period") görünecektir.
    • Kullanıcılar tarafından değiştirilmedikçe tüm yeni örneklere uygulanacak parametrenin varsayılan değeri (DefaultValue = 14).

    Aşağıdaki kodda, SmaPeriod özelliğinin gerçek bir işlem robotunda nasıl kullanılabileceğini gösteriyoruz.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
public class SamplecBotReferenceSMA : Robot
{
    [Parameter("Source")]
    public DataSeries Source { get; set; }

    [Parameter("SMA Period", DefaultValue = 14)]
    public int SmaPeriod { get; set; }

    private SampleSMA sma;

    protected override void OnStart()
    {
        sma = Indicators.GetIndicator<SampleSMA>(Source, SmaPeriod);
    }

    protected override void OnTick()
    {
        Print("{0}", sma.Result.LastValue);
    }
}

    Not

    Python cBot'ları, .cs dosyalarında bildirilen özelleştirilebilir parametreler kullanır.

    1
2
3
4
5
6
    class Sample_cBot():
    def on_start(self):
        self.sma = api.Indicators.GetIndicator<SampleSMA>(api.Source, api.SmaPeriod)

    def on_tick(self):
        api.Print(f"{self.sma.Result.LastValue}")

    Botumuz özelleştirilebilir SmaPeriod özelliğini alır ve başlangıçta değerini Indicators.GetIndicator<SampleSMA>() yöntemine iletir. Bu yöntem, belirtilen dönem için basit bir hareketli ortalama değeri döndürür.

    Bir cBot örneği oluştururken, tüm ayarlanabilir parametreler Örnek Ekle penceresinde ayarlanabilir.

    Başlatıldığında, cBot bize her tikte son basit hareketli ortalama değerinin ne olduğunu bildirir.

    Günlük çıktısı

    • CBot örneği [Sample cBot Reference SMA, EURUSD, h1] başlatıldı.
    • 0.975685714285714
    • 0.975681428571429
    • 0.97568
    • CBot örneği [Sample cBot Reference SMA, EURUSD, h1] kullanıcı tarafından durduruldu.

  • Daha fazla argümanla piyasa emri gerçekleştirme

    Önceki örnekte, ExecuteMarketOrder() yöntemine mümkün olan minimum sayıda argüman ilettik. Bunlar işlem türü (TradeType.Buy), sembol (Symbol) ve hacimdi (-1).

    ExecuteMarketOrder() yöntemi Label, StopLoss, TakeProfit ve Comment gibi ek argümanlarla çağrılabilir. Aşağıdaki örnek, etiketi ("order 1"), zarar durdur koruma mekanizmasını (10) ve kâr al seviyesini (10) belirtir.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
    [Robot(TimeZone = TimeZones.UTC)]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        var result = ExecuteMarketOrder(TradeType.Buy, SymbolName, 10000, "order 1", 10, 10);

        if (result.IsSuccessful)
        {
            var position = result.Position;
            Print("Position entry price is {0}", position.EntryPrice);
            Print("Position SL price is {0}", position.StopLoss);
        }
    }
}

    1
2
3
4
5
6
7
8
    class Sample_cBot():
    def on_start(self):
        result = api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, 10000, "order 1", 10, 10)

        if result.IsSuccessful:
            position = result.Position
            api.Print(f"Position entry price is {position.EntryPrice}")
            api.Print(f"Position SL price is {position.StopLoss}")

    Günlük çıktısı

    • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
    • 10000 EURUSD Almak İçin Piyasa Emri Gerçekleştiriliyor (ZD: 10, KA: 10)
    • 10000 EURUSD Almak İçin Piyasa Emri BAŞARILI (ZD: 10, KA: 10), Pozisyon PID14576098
    • Pozisyon giriş fiyatı 1.1896
    • Pozisyon ZD fiyatı 1.1886

Pozisyonu değiştir

Aşağıdaki örnekte, bir emir gerçekleştirildiğinde yalnızca bir kâr al değeri (10) ekliyoruz. Daha sonra, bir zarar durdur eklemek için pozisyonu değiştiriyoruz.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
[Robot()]
public class SamplecBbot : Robot
{
    protected override void OnStart()
    {
        var result = ExecuteMarketOrder(TradeType.Buy, SymbolName, 10000,
                                "order 1", null, 10);
        if (result.IsSuccessful)
        {
            var position = result.Position;
            Print("Position SL price is {0}", position.StopLoss);

            var stopLoss = position.EntryPrice - 10*Symbol.PipSize;
            ModifyPosition(position, stopLoss, position.TakeProfit);

            Print("New Position SL price is {0}", position.StopLoss);

        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Sample_cBot():
    def on_start(self):
        result = api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, 10000, "order 1", None, 10)

        if result.IsSuccessful:
            position = result.Position
            api.Print(f"Position SL price is {position.StopLoss}")
            stopLoss = position.EntryPrice - 10 * api.Symbol.PipSize
            api.ModifyPosition(position, stopLoss, position.TakeProfit)
            api.Print(f"New Position SL price is {position.StopLoss}")

Günlük çıktısı

  • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
  • 10000 EURUSD Almak İçin Piyasa Emri Gerçekleştiriliyor (KA: 10)
  • 10000 EURUSD Almak İçin Piyasa Emri BAŞARILI (KA: 10), Pozisyon PID14576161
  • Pozisyon ZD fiyatı boş
  • Pozisyon PID14576161 değiştiriliyor (ZD: 1.18744, KA: 1.18944)
  • Pozisyon PID14576161 değiştirme BAŞARILI (ZD: 1.18744, KA: 1.18944), Pozisyon PID14576161
  • Yeni Pozisyon ZD fiyatı 1.18744

Pozisyonu kapatma

  • Tam kapatma gerçekleştirme

    Aşağıdaki kod örneği bir piyasa emri verir. Ortaya çıkan pozisyonun brüt karı belirli bir değeri (null && position.GrossProfit > 10) aşarsa, kapatılır.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
    [Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        ExecuteMarketOrder(TradeType.Buy, SymbolName, 10000, "myLabel");
    }

    protected override void OnTick()
    {
        var position = Positions.Find("myLabel");
        if (position != null && position.GrossProfit > 10)
        {
            ClosePosition(position);
            Stop();
        }
    }
}

    1
2
3
4
5
6
7
8
9
    class Sample_cBot():
    def on_start(self):
        api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, 10000, "myLabel")

    def on_tick(self):
        position = api.Positions.Find("myLabel")
        if position is not None and position.GrossProfit > 10:
            api.ClosePosition(position)
            api.Stop()

    Günlük çıktısı

    • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
    • 10000 EURUSD Almak İçin Piyasa Emri Gerçekleştiriliyor
    • 10000 EURUSD Almak İçin Piyasa Emri BAŞARILI, Pozisyon PID14576180

  • Kısmi kapatma gerçekleştirme

    Önceki örneği, aynı etiketlere ("myLabel") sahip iki piyasa emri oluşturacak şekilde değiştireceğiz. Her yeni barda, işlem robotumuz bu emirlerden birinin tam yarısını kapatacaktır, ancak yalnızca hacmi 20.000'e eşit veya daha büyükse.

    Ayrıca Positions.FindAll() yöntemini kullanıyoruz. Bu, üzerinde yineleyebileceğimiz bir pozisyon listesi döndürür.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
    [Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        ExecuteMarketOrder(TradeType.Buy, SymbolName, 20000, "myLabel");
        ExecuteMarketOrder(TradeType.Buy, SymbolName, 30000, "myLabel");
    }

    protected override void OnBar()
    {
        var positions = Positions.FindAll("myLabel", SymbolName, TradeType.Buy);

        foreach (var position in positions)
        {
            if (position.VolumeInUnits >= 20000)
            {
                ClosePosition(position, 15000);
            }
        }
    }
}

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    class Sample_cBot():
    def on_start(self):
        api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, 20000, "myLabel")
        api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, 30000, "myLabel")

    def on_tick(self):
        positions = api.Positions.FindAll("myLabel", api.SymbolName, TradeType.Buy)
        for position in positions:
            if position.VolumeInUnits >= 20000:
                api.ClosePosition(position, 15000)

    Günlük çıktısı

    • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
    • 20000 EURUSD Almak İçin Piyasa Emri Gerçekleştiriliyor
    • 20000 EURUSD Almak İçin Piyasa Emri BAŞARILI, Pozisyon PID14579299
    • 30000 EURUSD Almak İçin Piyasa Emri Gerçekleştiriliyor
    • 30000 EURUSD Almak İçin Piyasa Emri BAŞARILI, Pozisyon PID14579300

Bekleyen emirler oluşturma

  • Limitli ve stop emirleri oluşturma

    Limitli ve stop emirleri bekleyen emirlerdir; buna rağmen, piyasa emirlerine benzer şekilde oluşturulurlar. Ancak, limitli ve stop emirleri oluştururken, hedef fiyatlarını da belirtmeniz gerekir ve kabul edilebilir slipaj yoktur.

    Bu cBot iki limitli emir ve bir stop emri oluşturur. Daha sonra emirler arasında yineler ve etiketlerini ve kimliklerini günlüğe yazdırır.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
    [Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        PlaceLimitOrder(TradeType.Buy, SymbolName, 10000, Symbol.Bid, "myLimitOrder");
        PlaceLimitOrder(TradeType.Buy, SymbolName, 20000, Symbol.Bid-2*Symbol.PipSize,
                "myLimitOrder");
        PlaceStopOrder(TradeType.Buy, SymbolName, 10000, Symbol.Ask, "myStopOrder");

        foreach (var pendingOrder in PendingOrders)
        {
            Print("Order placed with label {0}, id {1}", pendingOrder.Label, pendingOrder.Id);
        }
    }
}

    1
2
3
4
5
6
7
8
    class Sample_cBot():
    def on_start(self):
        api.PlaceLimitOrder(TradeType.Buy, api.SymbolName, 10000, api.Symbol.Bid, "myLimitOrder")
        api.PlaceLimitOrder(TradeType.Buy, api.SymbolName, 20000, api.Symbol.Bid - 2 * api.Symbol.PipSize, "myLimitOrder")
        api.PlaceStopOrder(TradeType.Buy, api.SymbolName, 10000, api.Symbol.Ask, "myStopOrder")

        for pendingOrder in api.PendingOrders:
            Print(f"Order placed with label {pendingOrder.Label}, id {pendingOrder.Id}")

    Günlük çıktısı

    • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
    • 10000 EURUSD Almak İçin Limitli Emir Veriliyor (Fiyat: 1.19036)
    • 10000 EURUSD Almak İçin Limitli Emir BAŞARILI (Fiyat: 1.19036), Bekleyen Emir OID25220794
    • 20000 EURUSD Almak İçin Limitli Emir Veriliyor (Fiyat: 1.19017)
    • 20000 EURUSD Almak İçin Limitli Emir BAŞARILI (Fiyat: 1.19017), Bekleyen Emir OID25220795
    • 10000 EURUSD Almak İçin Stop Emri Veriliyor (Fiyat: 1.19040)
    • 10000 EURUSD Almak İçin Stop Emri BAŞARILI (Fiyat: 1.19040), Bekleyen Emir OID25220796
    • myLimitOrder etiketli, id 25220794 numaralı emir verildi
    • myLimitOrder etiketli, id 25220795 numaralı emir verildi
    • myStopOrder etiketli, id 25220796 numaralı emir verildi

  • Daha fazla parametreyle bekleyen emirler oluşturma

    Piyasa emirlerinde olduğu gibi, emir etiketini, çeşitli koruma mekanizmalarını, emrin son kullanma tarihini de belirtebilir ve bir yorum sağlayabilirsiniz.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
    [Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        var midnight = Server.Time.AddDays(1).Date;

        PlaceLimitOrder(TradeType.Buy, SymbolName, 10000, Symbol.Bid, "mySample_cBot", 10, null, midnight, "First");

        PlaceStopOrder(TradeType.Buy, SymbolName, 10000, Symbol.Ask, "mySample_cBot", 10, 10, null, "Second");

        foreach (var order in PendingOrders)
        {
            var sl = order.StopLoss == null ? "" : "SL: " + order.StopLoss;
            var tp = order.TakeProfit == null ? "" : " TP: " + order.TakeProfit;

            var text = string.Format("{0} {1}", sl, tp);

            if (order.OrderType == PendingOrderType.Limit)
                Print(order.Comment + " Limit Order " + text);
            else
                Print(order.Comment + " Stop Order " + text);
        }
    }
}

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
    class Sample_cBot():
    def on_start(self):
        midnight = api.Server.Time.AddDays(1).Date

        api.PlaceLimitOrder(TradeType.Buy, api.SymbolName, 10000, api.Symbol.Bid, "mySample_cBot", 10, None, midnight, "First")
        api.PlaceStopOrder(TradeType.Buy, api.SymbolName, 10000, api.Symbol.Ask, "mySample_cBot", 10, 10, None, "Second")

        for order in api.PendingOrders:
            sl = "" if order.StopLoss is None else f"SL: {order.StopLoss}"
            tp = "" if order.TakeProfit is None else f"TP: {order.TakeProfit}"

            api.Print(f"{order.Comment} {order.OrderType} Order {sl} {tp}")

    Günlük çıktısı

    • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
    • 10000 EURUSD Almak İçin Limitli Emir Veriliyor (Fiyat: 1.19049, ZD: 10, Son Kullanma Tarihi: 12/05/2018 00:00:00)
    • 10000 EURUSD Almak İçin Limitli Emir BAŞARILI (Fiyat: 1.19049, ZD: 10, Son Kullanma Tarihi: 12/05/2018 00:00:00), Bekleyen Emir OID25220807
    • 10000 EURUSD Almak İçin Stop Emri Veriliyor (Fiyat: 1.19053, ZD: 10, KA: 10)
    • 10000 EURUSD Almak İçin Stop Emri BAŞARILI (Fiyat: 1.19053, ZD: 10, KA: 10), Bekleyen Emir OID25220808
    • Limitli Emir
    • İlk Limitli Emir ZD: 1.18949
    • İkinci Stop Emri ZD: 1.18953 KA: 1.19153

Bekleyen emirleri değiştir

Bekleyen emirlerin birkaç özelliğini değiştirmek mümkündür.

Aşağıdaki örnek, hedef fiyatın, koruma seviyelerinin veya bekleyen bir emrin son kullanma tarihinin ve saatinin nasıl değiştirileceğini gösterir.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        var price = Symbol.Ask + 10 * Symbol.PipSize;
        var expiry = Server.Time.AddHours(12);
        PlaceStopOrder(TradeType.Buy, SymbolName, 10000, price, "myLabel", 10, 10, expiry);
    }

    protected override void OnBar()
    {
        foreach (var order in PendingOrders)
        {
            if (order.Label == "myLabel")
            {
                double newPrice = Symbol.Ask + 5 * Symbol.PipSize;
                ModifyPendingOrder(order, newPrice, order.StopLossPips,
                                                            order.TakeProfitPips, order.ExpirationTime);
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
class Sample_cBot():
    def on_start(self):
        price = api.Symbol.Ask + 10 * api.Symbol.PipSize
        expiry = Server.Time.AddHours(12)

        api.PlaceStopOrder(TradeType.Buy, api.SymbolName, 10000, price, "myLabel", 10, 10, expiry)

    def on_bar(self):
        for order in api.PendingOrders:
            if order.Label == "myLabel":
                newPrice = api.Symbol.Ask + 5 * api.Symbol.PipSize
                api.ModifyPendingOrder(order, newPrice, order.StopLossPips, order.TakeProfitPips, order.ExpirationTime)

Günlük çıktısı

  • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
  • 10000 EURUSD Almak İçin Stop Emri Veriliyor (Fiyat: 1.19254, ZD: 10, KA: 10, Son Kullanma Tarihi: 11/05/2018 20:07:25)
  • 10000 EURUSD Almak İçin Stop Emri BAŞARILI (Fiyat: 1.19254, ZD: 10, KA: 10, Son Kullanma Tarihi: 11/05/2018 20:07:25), Bekleyen Emir OID25220877

Bekleyen emirleri iptal et

Bir emri iptal etme sözdizimi CancelPendingOrder(order) şeklindedir; burada order, PendingOrder türündedir.

Aşağıdaki örnek, "myLabel" etiketli tüm emirleri iptal etmeyi gösterir.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
[Robot()]
public class Sample_cBot : Robot
{
    protected override void OnTick()
    {
        foreach (var order in PendingOrders)
        {
            if (order.Label == "myLabel")
            {
                CancelPendingOrder(order);
            }
        }
    }
}

1
2
3
4
5
class Sample_cBot():
    def on_tick(self):
        for order in api.PendingOrders:
            if order.Label == "myLabel":
                api.CancelPendingOrder(order)

Pozisyon olayları

Çeşitli işlem operasyonlarıyla ilgili olaylara abone olmak mümkündür. Örneğin, bir pozisyonun açılıp açılmadığını test etmek için, açılışta tüm Position nesneleri için tetiklenen bir olaya abone oluruz.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
[Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        Positions.Opened += PositionsOnOpened;
        ExecuteMarketOrder(TradeType.Buy, Symbol, 10000, "myLabel", 10, 10);
    }

    private void PositionsOnOpened(PositionOpenedEventArgs args)
    {
        var pos = args.Position;
        Print("Position opened at {0}", pos.EntryPrice);
    }
}

1
2
3
4
5
6
7
8
class Sample_cBot():
    def on_start(self):
        api.Positions.Opened += self.on_position_opened
        api.ExecuteMarketOrder(TradeType.Buy, api.Symbol, 10000, "myLabel", 10, 10)

    def on_position_opened(self, args):
        pos = args.Position
        api.Print(f"Position opened at {pos.EntryPrice}")

Günlük çıktısı

  • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
  • 10000 EURUSD için Piyasa Emri Gerçekleştiriliyor (ZD: 10, KA: 10)
  • 10000 EURUSD için Piyasa Emri Gerçekleştirme (ZD: 10, KA: 10) BAŞARILI OLDU, Pozisyon PID14579468
  • Pozisyon 1.19224'ten açıldı

Benzer şekilde, bir pozisyon her kapatıldığında tetiklenen olaylara abone olmak mümkündür.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
[Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        Positions.Closed += PositionsOnClosed;
        ExecuteMarketOrder(TradeType.Buy, Symbol, 10000, "myLabel", 10, 10);
    }

    protected override void OnBar()
    {
        var position = Positions.Find("myLabel");
        if (position != null)
            ClosePosition(position);
    }

    private void PositionsOnClosed(PositionClosedEventArgs args)
    {
        var pos = args.Position;
        Print("Position closed with {0} profit", pos.GrossProfit);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
class Sample_cBot():
    def on_start(self):
        api.Positions.Closed += self.on_position_closed
        api.ExecuteMarketOrder(TradeType.Buy, api.Symbol, 10000, "myLabel", 10, 10)

    def on_bar(self):
        position = api.Positions.Find("myLabel")

        if position is not None:
            api.ClosePosition(position);            

    def on_position_closed(self, args):
        pos = args.Position
        api.Print(f"Position closed with {pos.GrossProfit} profit")

Günlük çıktısı

  • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
  • 10000 EURUSD için Piyasa Emri Gerçekleştiriliyor (ZD: 10, KA: 10)
  • 10000 EURUSD için Piyasa Emri Gerçekleştirme (ZD: 10, KA: 10) BAŞARILI OLDU, Pozisyon PID14579479
  • PID14579299 pozisyonu kapatılıyor
  • PID14579299 pozisyonu kapatma BAŞARILI OLDU, Pozisyon PID14579299
  • Pozisyon 20.64 kâr ile kapatıldı

Koordinat dönüştürme

Aşağıdaki cBot, kullanıcıların bir grafiğe sağ tıklayarak uygun yönde limitli emirler vermesini sağlar. Bunu, fare Y-koordinatlarını grafik Y-koordinatlarına (semboller için sembol fiyatlarına karşılık gelir) dönüştürerek başarır.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
[Robot(AccessRights = AccessRights.None)]
public class CoordinatesConverter : Robot
{
    protected override void OnStart()
    {
        Chart.MouseUp += Chart_MouseUp;
    }

    private void Chart_MouseUp(ChartMouseEventArgs obj)
    {
        var desiredPrice = Chart.YToYValue(obj.MouseY);
        var desiredTradeType = desiredPrice > Symbol.Bid ? TradeType.Sell : TradeType.Buy;
        PlaceLimitOrder(desiredTradeType, SymbolName, 10000, desiredPrice);
    }
}

1
2
3
4
5
6
7
8
class Sample_cBot():
    def on_start(self):
        api.Chart.MouseUp += self.on_chart_mouse_up        

    def on_chart_mouse_up(self, args):
        desiredPrice = api.Chart.YToYValue(args.MouseY)
        desiredTradeType = TradeType.Sell if desiredPrice > api.Symbol.Bid else TradeType.Buy
        api.PlaceLimitOrder(desiredTradeType, api.SymbolName, 10000, desiredPrice)

Asenkron yürütme

Yukarıdaki kod örnekleri, senkron yürütme kullanarak işlem robotları uygulamak için tasarlanmıştır. C# ve Python'ın her ikisi de asenkron işlemleri destekler ve cBot'unuzun aynı zaman dilimi içinde birden fazla eylem gerçekleştirmesine olanak tanır.

Piyasa emirlerini asenkron olarak gerçekleştir

Asenkron yöntemlerin söz dizimi, senkron yöntemlerinkine benzerdir. Aynı türde argümanları kabul etseler de, dönüş tipleri TradeResult yerine TradeOperation'dır.

  • Temel asenkron işlemler

    Aşağıdaki cBot, asenkron işlemlerin nasıl çalıştığını göstermektedir. Bir piyasa emri oluşturulur; bir sonraki koşulda cBot, işlemin yürütülüp yürütülmediğini kontrol eder.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
    [Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        var operation = ExecuteMarketOrderAsync(TradeType.Buy, SymbolName, 10000);

        if (operation.IsExecuting)
        {
            Print("Operation Is Executing");
        }
    }
}

    1
2
3
4
5
6
    class Sample_cBot():
    def on_start(self):
        operation = api.ExecuteMarketOrderAsync(TradeType.Buy, api.SymbolName, 10000)

        if operation.IsExecuting:
            api.Print("Operation Is Executing")

    Günlük çıktısı

    • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
    • 10000 EURUSD için Piyasa Emri Gerçekleştiriliyor
    • İşlem Yürütülüyor
    • 10000 EURUSD için Piyasa Emri Gerçekleştirme BAŞARILI OLDU, Pozisyon PID14579532

  • Bir emir gerçekleştir

    Bir sonraki örnek, senkron ve asenkron yöntemler arasındaki farkı vurgulamaktadır.

    cBot, asenkron bir yöntem çağrıldıktan hemen sonra bir işlemin yürütülüp yürütülmediğini kontrol eder. Senkron bir yöntem çağrıldıktan sonra bunu tekrar yapar. Bu iki eylem için günlük çıktısı farklıdır.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    [Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        var operation = ExecuteMarketOrderAsync(TradeType.Buy, SymbolName, 10000);
        Print(operation.IsExecuting ? "Operation Is Executing" : "Operation executed");
        ExecuteMarketOrder(TradeType.Buy, SymbolName, 20000);
        Print(operation.IsExecuting ? "Operation Is Executing" : "Operation executed");
    }
}

    1
2
3
4
5
6
    class Sample_cBot():
    def on_start(self):
        operation = api.ExecuteMarketOrderAsync(TradeType.Buy, api.SymbolName, 10000)
        api.Print("Operation Is Executing" if operation.IsExecuting else "Operation executed")
        api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, 20000)
        api.Print("Operation Is Executing" if operation.IsExecuting else "Operation executed")

    Günlük çıktısı

    • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
    • 10000 EURUSD için Piyasa Emri Gerçekleştiriliyor
    • İşlem Yürütülüyor
    • 20000 EURUSD için Piyasa Emri Gerçekleştiriliyor
    • 10000 EURUSD için Piyasa Emri Gerçekleştirme BAŞARILI OLDU, Pozisyon PID14579541
    • 20000 EURUSD için Piyasa Emri Gerçekleştirme BAŞARILI OLDU, Pozisyon PID14579542
    • İşlem yürütüldü

  • Daha fazla parametreyle bir emir gerçekleştir

    Aşağıdaki cBot, etiketini ("myLabel"), koruma seviyelerini (10, 10), sembolünü (SymbolName) ve hacmini (10000) belirterek bir emir verir.

    Örnek ayrıca Positions koleksiyonunu ve FindAll() yöntemini içermektedir. Find() ve FindAll() aynı etiket, sembol ve işlem türüne sahip pozisyonları bulmak için kullanılabilir.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
    [Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        ExecuteMarketOrderAsync(TradeType.Buy, SymbolName, 10000, "myLabel", 10, 10);
    }
    protected override void OnTick()
    {
        var positions = Positions.FindAll("myLabel", SymbolName, TradeType.Buy);

        if (positions.Length == 0)
            return;

        foreach (var position in positions)
            Print("Buy at {0} SL {1}", position.EntryPrice, position.StopLoss);

        Stop();
    }
}

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
    class Sample_cBot():
    def on_start(self):
        api.ExecuteMarketOrderAsync(TradeType.Buy, api.SymbolName, 10000, "myLabel", 10, 10)

    def on_tick(self):
        positions = api.Positions.FindAll("myLabel", api.SymbolName, TradeType.Buy)

        if positions.Length == 0:
            return

        for position in positions:
            api.Print(f"Buy at {position.EntryPrice} SL {position.StopLoss}")

        api.Stop()

    Günlük çıktısı

    • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
    • 10000 EURUSD için Piyasa Emri Gerçekleştiriliyor (ZD: 10, KA: 10)
    • 10000 EURUSD için Piyasa Emri Gerçekleştirme (ZD: 10, KA: 10) BAŞARILI OLDU, Pozisyon PID14579719
    • 1.19087'den Al ZD boş
    • 1.19357'den Al ZD 1.19257
    • New cBot" cBot'u EURUSD, h1 için durduruldu."

Pozisyonu asenkron olarak değiştir

Aşağıdaki cBot bir piyasa emri verir ve ardından yeni açılan pozisyonu değiştirir.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
[Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        ExecuteMarketOrderAsync(TradeType.Buy, SymbolName, 10000, "myLabel", null, 10);
    }

    protected override void OnTick()
    {
        Position myPosition = Positions.Find("myLabel");
        if (myPosition != null && myPosition.StopLoss == null)
        {
            double stopLoss = Symbol.Bid - 10 * Symbol.PipSize;
            ModifyPositionAsync(myPosition, stopLoss, myPosition.TakeProfit);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
class Sample_cBot():
    def on_start(self):
        api.ExecuteMarketOrderAsync(TradeType.Buy, api.SymbolName, 10000, "myLabel", None, 10)

    def on_tick(self):
        myPosition = Positions.Find("myLabel")

        if myPosition is None or myPosition.StopLoss is not None:
            return

        stopLoss = api.Symbol.Bid - 10 * api.Symbol.PipSize

        api.ModifyPositionAsync(myPosition, stopLoss, myPosition.TakeProfit)

Günlük çıktısı

  • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
  • 10000 EURUSD için Piyasa Emri Gerçekleştiriliyor (KA: 10)
  • 10000 EURUSD için Piyasa Emri Gerçekleştirme (KA: 10) BAŞARILI OLDU, Pozisyon PID14579736
  • PID14579300 pozisyonu değiştiriliyor (ZD: 1.19213, KA: boş)
  • PID14579300 pozisyonu değiştirme (ZD: 1.19213, KA: boş) BAŞARILI OLDU, Pozisyon PID14579300

Bir pozisyonu asenkron olarak kapat

Bir sonraki örnek, bir pozisyon mevcutsa onu asenkron olarak kapatmayı göstermektedir.

Belirli bir etikete sahip pozisyonu Positions koleksiyonunda aramak için Find() yöntemi kullanılır.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
[Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        ExecuteMarketOrderAsync(TradeType.Buy, Symbol, 10000, "myLabel", null, 10);
    }

    protected override void OnTick()
    {
        Position myPosition = Positions.Find("myLabel");
        if (myPosition != null && myPosition.GrossProfit > 10)
        {
            ClosePositionAsync(myPosition);
            Stop();
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
class Sample_cBot():
    def on_start(self):
        api.ExecuteMarketOrderAsync(TradeType.Buy, api.SymbolName, 10000, "myLabel", None, 10)

    def on_tick(self):
        myPosition = Positions.Find("myLabel")

        if myPosition is None or myPosition.GrossProfit <= 10:
            return

        api.ClosePositionAsync(myPosition)
        api.Stop()

Günlük çıktısı

  • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
  • 10000 EURUSD için Piyasa Emri Gerçekleştiriliyor (KA: 10)
  • 10000 EURUSD için Piyasa Emri Gerçekleştirme (KA: 10) BAŞARILI OLDU, Pozisyon PID14579740
  • PID14579300 pozisyonu kapatılıyor
  • PID14579300 pozisyonu kapatma BAŞARILI OLDU, Pozisyon PID14579300
  • New cBot" cBot'u EURUSD, h1 için durduruldu."

Limitli ve stop emirlerini asenkron olarak ver

Yukarıda belirtildiği gibi, bekleyen emirler vermek piyasa emirleri oluşturmaya benzerdir.

Ancak, bu iki yöntem arasındaki argümanlarda bazı küçük farklılıklar vardır. Kabul edilebilir slipaj argüman listesinde yoktur. Ayrıca, hedef fiyatı belirtmeniz gerekir ve emrin sona erme tarihini belirten isteğe bağlı bir argüman geçirebilirsiniz.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
[Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        var expiry = Server.Time.AddHours(12);
        PlaceLimitOrderAsync(TradeType.Buy, SymbolName, 10000, Symbol.Bid, "myLabel", null, null, expiry);
        PlaceStopOrderAsync(TradeType.Buy, SymbolName, 10000, Symbol.Ask + 10 * Symbol.PipSize, "myLabel", null, null, expiry);
    }
}

1
2
3
4
5
class Sample_cBot():
    def on_start(self):
        expiry = api.Server.Time.AddHours(12)
        api.PlaceLimitOrderAsync(TradeType.Buy, api.SymbolName, 10000, api.Symbol.Bid, "myLabel", None, None, expiry)
        api.PlaceStopOrderAsync(TradeType.Buy, api.SymbolName, 10000, api.Symbol.Ask + 10 * api.Symbol.PipSize, "myLabel", None, None, expiry)

Günlük çıktısı

  • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
  • 10000 EURUSD için Limitli Alış Emri Veriliyor (Fiyat: 1.19382, Sona Erme Zamanı: 12/05/2018 00:18:19)
  • 10000 EURUSD için Stoplu Alış Emri Veriliyor (Fiyat: 1.19487, Sona Erme Zamanı: 12/05/2018 00:18:19)
  • 10000 EURUSD için Limitli Alış Emri Verme (Fiyat: 1.19382, Sona Erme Zamanı: 12/05/2018 00:18:19) BAŞARILI OLDU, Bekleyen Emir OID25221859
  • 10000 EURUSD için Stoplu Alış Emri Verme (Fiyat: 1.19487, Sona Erme Zamanı: 12/05/2018 00:18:19) BAŞARILI OLDU, Bekleyen Emir OID25221860

Bekleyen emirleri asenkron olarak değiştir

Aşağıdaki cBot, limitli emirleri asenkron olarak değiştirir.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
[Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        var expiry = Server.Time.AddHours(12);
        PlaceLimitOrderAsync(TradeType.Buy, SymbolName, 10000, Symbol.Bid, "myLabel", null, 10, expiry);

    }
    protected override void OnTick()
    {
        foreach (var order in PendingOrders)
        {
            if (order.Label == "myLabel" && order.StopLoss == null)
                ModifyPendingOrderAsync(order, order.TargetPrice, 10, 10, null);
        }
    }
}

1
2
3
4
5
6
7
8
9
class Sample_cBot():
    def on_start(self):
        expiry = api.Server.Time.AddHours(12)
        api.PlaceLimitOrderAsync(TradeType.Buy, api.SymbolName, 10000, api.Symbol.Bid, "myLabel", None, 10, expiry)

    def on_tick(self):
        for order in api.PendingOrders:
            if order.Label == "myLabel" and order.StopLoss is None:
                api.ModifyPendingOrderAsync(order, order.TargetPrice, 10, 10, None)

Günlük çıktısı

  • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
  • 10000 EURUSD için Limitli Alış Emri Veriliyor (Fiyat: 1.19347, KA: 10, Sona Erme Zamanı: 12/05/2018 00:22:08)
  • OID25221860 bekleyen emri değiştiriliyor (Hacim: 10000, Fiyat: 1.19487, ZD: 10, KA: 10, Sona Erme Zamanı: 12/05/2018 00:18:19)
  • 10000 EURUSD için Limitli Alış Emri Verme (Fiyat: 1.19347, KA: 10, Sona Erme Zamanı: 12/05/2018 00:22:08) BAŞARILI OLDU, Bekleyen Emir OID25221906
  • OID25221860 bekleyen emri değiştirme (Hacim: 10000, Fiyat: 1.19487, ZD: 10, KA: 10, Sona Erme Zamanı: 12/05/2018 00:18:19) BAŞARILI OLDU, Bekleyen Emir OID25221860
  • OID25221906 bekleyen emri değiştiriliyor (Hacim: 10000, Fiyat: 1.19347, ZD: 10, KA: 10, Sona Erme Zamanı: 12/05/2018 00:22:08)
  • OID25221906 bekleyen emri değiştirme (Hacim: 10000, Fiyat: 1.19347, ZD: 10, KA: 10, Sona Erme Zamanı: 12/05/2018 00:22:08) BAŞARILI OLDU, Bekleyen Emir OID25221906

Bekleyen emirleri asenkron olarak iptal et

  • Tüm bekleyen emirleri iptal et

    Aşağıdaki cBot, mevcut tüm bekleyen emirleri asenkron olarak iptal eder.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    [Robot()]
public class Sample_cBot : Robot
{
    protected override void OnBar()
    {
        foreach (var pendingOrder in PendingOrders)
        {
            CancelPendingOrderAsync(pendingOrder);
        }
    }
}

    1
2
3
4
    class Sample_cBot():
    def on_bar(self):
        for order in api.PendingOrders:
            api.CancelPendingOrderAsync(order)

    Günlük çıktısı

    • "bekleyen emri iptal et" cBot'u EURUSD, h1 için başarıyla başlatıldı.
    • OID274705 bekleyen emri iptal ediliyor
    • OID274706 bekleyen emri iptal ediliyor
    • OID274707 bekleyen emri iptal ediliyor
    • OID274708 bekleyen emri iptal ediliyor
    • OID274709 bekleyen emri iptal ediliyor
    • OID274705 bekleyen emri iptal etme BAŞARILI OLDU, Bekleyen Emir OID274705
    • OID274706 bekleyen emri iptal etme BAŞARILI OLDU, Bekleyen Emir OID274706
    • OID274707 bekleyen emri iptal etme BAŞARILI OLDU, Bekleyen Emir OID274707
    • OID274708 bekleyen emri iptal etme BAŞARILI OLDU, Bekleyen Emir OID274708
    • OID274709 bekleyen emri iptal etme BAŞARILI OLDU, Bekleyen Emir OID274709

  • Belirli bir etikete sahip bekleyen emirleri iptal et

    Bu cBot yalnızca belirli bir etikete sahip bekleyen emirleri iptal eder.

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
    [Robot()]
public class Sample_cBot : Robot
{
    protected override void OnBar()
    {
        foreach (var pendingOrder in PendingOrders)
        {
            if (pendingOrder.Label == "myLabel")
                CancelPendingOrderAsync(pendingOrder);
        }
    }
}

    1
2
3
4
5
    class Sample_cBot():
    def on_bar(self):
        for order in api.PendingOrders:
            if order.Label == "myLabel":
                api.CancelPendingOrderAsync(order)

Asenkron yöntemler için geri arama fonksiyonları

Bir sonuç döndürüldüğünde, asenkron işlemlerin kullanılması genellikle yürütmeyi kontrol etmeyi gerektirir. Bunu ele almak için, tüm asenkron yöntemlerin parametre listesinin sonuna bir geri arama fonksiyonu ekleyebilirsiniz.

Bu fonksiyon, sunucudan bir yanıt alındığında hemen çağrılacaktır. Örneğin, bir pozisyon açıldığında, değiştirildiğinde veya kapatıldığında çağrılabilir.

  • Geri arama ile asenkron piyasa emri

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
    [Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        var operation = ExecuteMarketOrderAsync(TradeType.Buy, SymbolName, 10000, PositionOpened);
        if (operation.IsExecuting)
            Print(operation.ToString());
        else
            Print(operation.TradeResult.ToString());

    }

    private void PositionOpened(TradeResult tradeResult)
    {
        var position = tradeResult.Position;
        Print(tradeResult.ToString());
        if (tradeResult.IsSuccessful)
            Print("Position {0} opened at {1}", position.Id, position.EntryPrice);
    }
}

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
    from System import Action

class Sample_cBot():
    def on_start(self):
        operation = api.ExecuteMarketOrderAsync(TradeType.Buy, api.SymbolName, 10000, Action[TradeResult](self.on_position_opened))

        if (operation.IsExecuting)
            api.Print(operation.ToString())
        else
            api.Print(operation.TradeResult.ToString())

    def on_position_opened(self, tradeResult):
        position = tradeResult.Position

        api.Print(tradeResult.ToString())

        if tradeResult.IsSuccessful:
            api.Print(f"Position {position.Id} opened at {position.EntryPrice}")

    Günlük çıktısı

    • "New cBot" cBot'u EURUSD, h1 için başarıyla başlatıldı.
    • 10000 EURUSD Almak İçin Piyasa Emri Gerçekleştiriliyor
    • İşlem Operasyonu (10000 EURUSD Almak İçin Piyasa Emri Gerçekleştiriliyor YÜRÜTÜLÜYOR)
    • 10000 EURUSD Almak İçin Piyasa Emri Gerçekleştiriliyor BAŞARILI OLDU, Pozisyon PID14579835
    • İşlem Sonucu (Başarılı, Pozisyon: PID14579835)
    • Pozisyon 14579835 1.19414'ten açıldı

  • Lambda ifadelerini kullanma

    Adlandırılmış bir geri arama yöntemi tanımlamak yerine lambda ifadelerini kullanabilirsiniz.

    Aşağıdaki örnekte, bir emir verildiğinde sonucun açıklaması günlüğe yazdırılacaktır.

    1
2
3
4
5
6
7
8
9
    [Robot()]
public class Sample_cBot : Robot
{
    protected override void OnStart()
    {
        PlaceLimitOrderAsync(TradeType.Buy, SymbolName, 10000,
                Symbol.Ask - 20 * Symbol.PipSize, "myLabel", result => Print(result.ToString()));
    }
}

    1
2
3
4
5
    from System import Action

class Samples():
    def on_start(self):
        operation = api.PlaceLimitOrderAsync(TradeType.Buy, api.SymbolName, 10000, api.Symbol.Ask - 20 * api.Symbol.PipSize, "myLabel", Action[TradeResult](lambda result: api.Print(result.ToString())))

    Günlük çıktısı

    • cBot "Yeni cBot" EURUSD, h1 için başarıyla başlatıldı.
    • 10000 EURUSD Almak İçin Limit Emri Veriliyor (Fiyat: 1.19320)
    • 10000 EURUSD Almak İçin Limit Emri Veriliyor (Fiyat: 1.19320) BAŞARILI OLDU, Bekleyen Emir OID25222083
    • İşlem Sonucu (Başarılı, Bekleyen Emir: OID25222083)

Image title