Langkau tajuk talian

Sampel kod cBot

Halaman ini menyediakan beberapa contoh kod Python dan C# untuk mencipta robot dagangan dan membangunkan algoritma. Perhatikan bahawa tiada cBot yang disenaraikan di bawah menjamin sebarang pulangan kewangan. Pastikan untuk melakukan ujian belakang dan menyesuaikan cBot anda sebelum melaksanakan sebarang instans pada akaun langsung.

Repositori sampel cBot

Sampel kod cBot yang komprehensif, termasuk templat sedia untuk pelbagai strategi automatik dan gaya dagangan, tersedia dalam repositori Python dan C# yang berasingan di GitHub.

Operasi segerak

Semua cBot dalam bahagian ini melaksanakan operasi mereka secara segerak.

Laksanakan pesanan pasaran

  • Sebuah cBot mudah yang melakukan operasi berjaya

    Robot dagangan berikut mencipta pesanan pasaran semasa permulaan dan menyimpan hasilnya dalam pembolehubah result.

    Jika pelaksanaan pesanan berjaya, harga kemasukan akan dicetak dalam log.

     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}")

    Output log

    • cBot "New cBot" telah berjaya dimulakan untuk EURUSD, h1.
    • Melaksanakan Pesanan Pasaran untuk Beli 10000 EURUSD
    • Melaksanakan Pesanan Pasaran untuk Beli 10000 EURUSD BERJAYA, Posisi PID14576001
    • Harga kemasukan posisi ialah 1.19067

  • Sebuah cBot mudah dengan parameter yang boleh disesuaikan

    Apabila mengisytiharkan pelbagai sifat cBot, anda boleh menjadikannya parameter yang boleh disesuaikan menggunakan pengisytiharan [Parameter()]. Apabila instans baru cBot anda dilancarkan, anda (atau pengguna lain) akan dapat menetapkan nilai tersuai kepada parameter ini.

    Pertimbangkan contoh berikut.

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

    Nota

    cBot Python menggunakan parameter yang boleh disesuaikan yang diisytiharkan dalam fail .cs mereka.

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

    Dalam contoh di atas, kami menentukan ciri-ciri berikut:

    • Nama parameter. Ia akan, seterusnya, muncul dalam UI cTrader ("SMA Period").
    • Nilai lalai parameter yang akan digunakan untuk semua instans baru melainkan ia diubah oleh pengguna (DefaultValue = 14).

    Dalam kod di bawah, kami menunjukkan bagaimana sifat SmaPeriod boleh digunakan dalam robot dagangan sebenar.

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

    Nota

    cBot Python menggunakan parameter yang boleh disesuaikan yang diisytiharkan dalam fail .cs mereka.

    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}")

    Bot kami mengambil sifat SmaPeriod yang boleh disesuaikan dan, pada permulaan, menghantar nilainya kepada kaedah Indicators.GetIndicator<SampleSMA>(). Kaedah ini mengembalikan nilai purata bergerak mudah untuk tempoh yang ditentukan.

    Apabila mencipta instans cBot, semua parameter yang boleh disesuaikan boleh ditetapkan dalam tetingkap Tambah instans.

    Apabila dilancarkan, cBot akan memaklumkan kami tentang nilai purata bergerak mudah terakhir pada setiap tik.

    Output log

    • Instans CBot [Sample cBot Reference SMA, EURUSD, h1] telah dimulakan.
    • 0.975685714285714
    • 0.975681428571429
    • 0.97568
    • Instans CBot [Sample cBot Reference SMA, EURUSD, h1] dihentikan oleh pengguna.

  • Laksanakan pesanan pasaran dengan lebih banyak argumen

    Dalam contoh sebelumnya, kami menghantar bilangan argumen minimum yang mungkin kepada kaedah ExecuteMarketOrder(). Ia adalah jenis dagangan (TradeType.Buy), simbol (Symbol) dan volum (-1).

    Kaedah ExecuteMarketOrder() boleh dipanggil dengan argumen tambahan seperti Label, StopLoss, TakeProfit dan Comment. Contoh di bawah menentukan label ("order 1"), mekanisme perlindungan henti rugi (10) dan tahap ambilan untung (10).

     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}")

    Output log

    • cBot "New cBot" telah berjaya dimulakan untuk EURUSD, h1.
    • Melaksanakan Pesanan Pasaran untuk Beli 10000 EURUSD (SL: 10, TP: 10)
    • Melaksanakan Pesanan Pasaran untuk Beli 10000 EURUSD (SL: 10, TP: 10) BERJAYA, Posisi PID14576098
    • Harga kemasukan posisi ialah 1.1896
    • Harga SL posisi ialah 1.1886

Ubah suai posisi

Dalam contoh di bawah, kami hanya menambah nilai ambilan untung (10) apabila pesanan dilaksanakan. Selepas itu, kami mengubah suai posisi untuk menambah henti rugi.

 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}")

Output log

Tutup posisi

  • Lakukan penutupan penuh

    Sampel kod di bawah meletakkan pesanan pasaran. Jika keuntungan kasar posisi yang terhasil melebihi nilai tertentu (null && position.GrossProfit > 10), ia akan ditutup.

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

    Output log

    • cBot "New cBot" telah berjaya dimulakan untuk EURUSD, h1.
    • Melaksanakan Pesanan Pasaran untuk Beli 10000 EURUSD
    • Melaksanakan Pesanan Pasaran untuk Beli 10000 EURUSD BERJAYA, Posisi PID14576180

  • Lakukan penutupan separa

    Kami akan mengubah suai contoh sebelumnya untuk mencipta dua pesanan pasaran dengan label yang sama ("myLabel"). Pada setiap bar baharu, robot dagangan kami akan menutup tepat separuh daripada salah satu pesanan ini tetapi hanya jika volumnya sama dengan atau melebihi 20,000.

    Kami juga menggunakan kaedah Positions.FindAll(). Ia mengembalikan senarai posisi yang boleh kami ulangi.

     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)

    Output log

    • cBot "New cBot" telah berjaya dimulakan untuk EURUSD, h1.
    • Melaksanakan Pesanan Pasaran untuk Beli 20000 EURUSD
    • Melaksanakan Pesanan Pasaran untuk Beli 20000 EURUSD BERJAYA, Posisi PID14579299
    • Melaksanakan Pesanan Pasaran untuk Beli 30000 EURUSD
    • Melaksanakan Pesanan Pasaran untuk Beli 30000 EURUSD BERJAYA, Posisi PID14579300

Buat pesanan tertangguh

  • Buat pesanan had dan henti

    Pesanan had dan henti adalah pesanan tertangguh; walaupun begitu, ia dibuat sama seperti pesanan pasaran. Walau bagaimanapun, apabila membuat pesanan had dan henti, anda juga perlu menentukan harga sasaran mereka dan tiada julat pasaran.

    cBot ini mencipta dua pesanan had dan satu pesanan henti. Ia kemudian mengulangi pesanan tersebut dan mencetak label dan ID mereka ke log.

     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}")

    Output log

    • cBot "New cBot" telah berjaya dimulakan untuk EURUSD, h1.
    • Meletakkan Pesanan Had untuk Beli 10000 EURUSD (Harga: 1.19036)
    • Meletakkan Pesanan Had untuk Beli 10000 EURUSD (Harga: 1.19036) BERJAYA, PesananTertangguh OID25220794
    • Meletakkan Pesanan Had untuk Beli 20000 EURUSD (Harga: 1.19017)
    • Meletakkan Pesanan Had untuk Beli 20000 EURUSD (Harga: 1.19017) BERJAYA, PesananTertangguh OID25220795
    • Meletakkan Pesanan Henti untuk Beli 10000 EURUSD (Harga: 1.19040)
    • Meletakkan Pesanan Henti untuk Beli 10000 EURUSD (Harga: 1.19040) BERJAYA, PesananTertangguh OID25220796
    • Pesanan diletakkan dengan label myLimitOrder, id 25220794
    • Pesanan diletakkan dengan label myLimitOrder, id 25220795
    • Pesanan diletakkan dengan label myStopOrder, id 25220796

  • Buat pesanan tertangguh dengan lebih banyak parameter

    Seperti dalam kes pesanan pasaran, anda juga boleh menentukan label pesanan, pelbagai mekanisme perlindungan, tarikh tamat tempoh pesanan dan memberikan komen.

     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}")

    Output log

    • cBot "New cBot" telah berjaya dimulakan untuk EURUSD, h1.
    • Meletakkan Pesanan Had untuk Beli 10000 EURUSD (Harga: 1.19049, SL: 10, ExpireTime: 12/05/2018 00:00:00)
    • Meletakkan Pesanan Had untuk Beli 10000 EURUSD (Harga: 1.19049, SL: 10, ExpireTime: 12/05/2018 00:00:00) BERJAYA, PesananTertangguh OID25220807
    • Meletakkan Pesanan Henti untuk Beli 10000 EURUSD (Harga: 1.19053, SL: 10, TP: 10)
    • Meletakkan Pesanan Henti untuk Beli 10000 EURUSD (Harga: 1.19053, SL: 10, TP: 10) BERJAYA, PesananTertangguh OID25220808
    • Pesanan Had
    • Pesanan Had Pertama SL: 1.18949
    • Pesanan Henti Kedua SL: 1.18953 TP: 1.19153

Ubah suai pesanan tertangguh

Adalah mungkin untuk mengubah suai beberapa ciri pesanan tertangguh.

Contoh di bawah menunjukkan cara mengubah suai harga sasaran, tahap perlindungan atau tarikh dan masa tamat tempoh pesanan tertangguh.

 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)

Output log

Batalkan pesanan tertangguh

Sintaks untuk membatalkan pesanan ialah CancelPendingOrder(order), di mana order adalah jenis PendingOrder.

Contoh di bawah menunjukkan pembatalan semua pesanan dengan label "myLabel".

 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)

Peristiwa posisi

Adalah mungkin untuk melanggan peristiwa yang berkaitan dengan pelbagai operasi dagangan. Sebagai contoh, untuk menguji sama ada posisi dibuka, kita melanggan peristiwa yang dibangkitkan untuk semua objek Position pada pembukaan.

 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}")

Output log

Begitu juga, adalah mungkin untuk melanggan peristiwa yang dibangkitkan setiap kali posisi ditutup.

 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")

Output log

Penukaran koordinat

cBot di bawah membolehkan pengguna meletakkan pesanan had dalam arah yang sesuai hanya dengan mengklik kanan pada carta. Ia mencapai ini dengan menukar koordinat Y tetikus kepada koordinat Y carta (yang, untuk simbol, sepadan dengan harga simbol).

 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)

Pelaksanaan tak segerak

Sampel kod di atas direka untuk melaksanakan robot dagangan menggunakan pelaksanaan segerak. C# dan Python kedua-duanya menyokong operasi tak segerak, membolehkan cBot anda melakukan beberapa tindakan dalam tempoh masa yang sama.

Laksanakan pesanan pasaran secara tak segerak

Sintaks kaedah tak segerak adalah serupa dengan kaedah segerak. Walaupun mereka menerima jenis argumen yang sama, jenis pulangan mereka ialah TradeOperation dan bukannya TradeResult.

  • Operasi tak segerak asas

    cBot berikut menunjukkan bagaimana operasi tak segerak berfungsi. Pesanan pasaran dicipta; dalam keadaan bersyarat seterusnya, cBot menyemak sama ada operasi sedang dilaksanakan.

     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")

    Output log

    • cBot "New cBot" telah berjaya dimulakan untuk EURUSD, h1.
    • Melaksanakan Pesanan Pasaran untuk Beli 10000 EURUSD
    • Operasi Sedang Dilaksanakan
    • Melaksanakan Pesanan Pasaran untuk Beli 10000 EURUSD BERJAYA, Position PID14579532

  • Laksanakan pesanan

    Contoh seterusnya menyerlahkan perbezaan antara kaedah segerak dan tak segerak.

    cBot menyemak sama ada operasi sedang dilaksanakan sejurus selepas memanggil kaedah tak segerak. Ia melakukannya sekali lagi selepas memanggil kaedah segerak. Output log untuk kedua-dua tindakan ini adalah berbeza.

     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")

    Output log

    • cBot "New cBot" telah berjaya dimulakan untuk EURUSD, h1.
    • Melaksanakan Pesanan Pasaran untuk Beli 10000 EURUSD
    • Operasi Sedang Dilaksanakan
    • Melaksanakan Pesanan Pasaran untuk Beli 20000 EURUSD
    • Melaksanakan Pesanan Pasaran untuk Beli 10000 EURUSD BERJAYA, Position PID14579541
    • Melaksanakan Pesanan Pasaran untuk Beli 20000 EURUSD BERJAYA, Position PID14579542
    • Operasi dilaksanakan

  • Laksanakan pesanan dengan lebih banyak parameter

    cBot berikut meletakkan pesanan dengan menentukan labelnya ("myLabel"), tahap perlindungan (10, 10), simbol (SymbolName) dan volum (10000).

    Contoh ini juga mengandungi koleksi Positions dan kaedah FindAll(). Find() dan FindAll() boleh digunakan untuk mencari posisi dengan label, simbol dan jenis dagangan yang sama.

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

    Output log

    • cBot "New cBot" telah berjaya dimulakan untuk EURUSD, h1.
    • Melaksanakan Pesanan Pasaran untuk Beli 10000 EURUSD (SL: 10, TP: 10)
    • Melaksanakan Pesanan Pasaran untuk Beli 10000 EURUSD (SL: 10, TP: 10) BERJAYA, Position PID14579719
    • Beli pada 1.19087 SL null
    • Beli pada 1.19357 SL 1.19257
    • cBot "New cBot" telah dihentikan untuk EURUSD, h1.

Ubah suai posisi secara tak segerak

cBot di bawah meletakkan pesanan pasaran dan kemudian mengubah suai posisi yang baru dibuka.

 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)

Output log

Tutup posisi secara tak segerak

Contoh seterusnya menunjukkan menutup posisi secara tak segerak jika ia wujud.

Kaedah Find() digunakan untuk mencari koleksi Positions untuk posisi dengan label tertentu.

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

Output log

Letakkan pesanan had dan henti secara tak segerak

Seperti yang dinyatakan di atas, meletakkan pesanan tertangguh adalah serupa dengan mencipta pesanan pasaran.

Walau bagaimanapun, terdapat beberapa perbezaan kecil dalam argumen antara kedua-dua kaedah ini. Julat pasaran tiada dalam senarai argumen. Selain itu, anda perlu menentukan harga sasaran, dan anda boleh menghantar argumen pilihan yang menentukan tarikh tamat tempoh pesanan.

 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)

Output log

Ubah suai pesanan tertangguh secara asinkron

cBot berikut mengubah suai pesanan had secara asinkron.

 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)

Output log

Batalkan pesanan tertangguh secara asinkron

  • Batalkan semua pesanan tertangguh

    cBot di bawah membatalkan semua pesanan tertangguh semasa secara asinkron.

     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)

    Output log

    • cBot "batalkan pesanan tertangguh" telah bermula dengan berjaya untuk EURUSD, h1.
    • Membatalkan pesanan tertangguh OID274705
    • Membatalkan pesanan tertangguh OID274706
    • Membatalkan pesanan tertangguh OID274707
    • Membatalkan pesanan tertangguh OID274708
    • Membatalkan pesanan tertangguh OID274709
    • Membatalkan pesanan tertangguh OID274705 BERJAYA, PendingOrder OID274705
    • Membatalkan pesanan tertangguh OID274706 BERJAYA, PendingOrder OID274706
    • Membatalkan pesanan tertangguh OID274707 BERJAYA, PendingOrder OID274707
    • Membatalkan pesanan tertangguh OID274708 BERJAYA, PendingOrder OID274708
    • Membatalkan pesanan tertangguh OID274709 BERJAYA, PendingOrder OID274709

  • Batalkan pesanan tertangguh dengan label tertentu

    cBot ini hanya membatalkan pesanan tertangguh dengan label tertentu.

     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)

Fungsi panggilan balik untuk kaedah asinkron

Setelah keputusan dikembalikan, penggunaan operasi asinkron sering memerlukan kawalan pelaksanaan. Untuk mengendalikan ini, anda boleh menambah fungsi panggilan balik pada akhir senarai parameter semua kaedah asinkron.

Fungsi ini akan dipanggil sebaik sahaja respons diterima dari pelayan. Sebagai contoh, ia boleh dipanggil apabila posisi dibuka, diubah suai atau ditutup.

  • Pesanan pasaran asinkron dengan panggilan balik

     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}")

    Output log

    • cBot "New cBot" telah berjaya dimulakan untuk EURUSD, h1.
    • Melaksanakan Pesanan Pasaran untuk Membeli 10000 EURUSD
    • TradeOperation (Melaksanakan Pesanan Pasaran untuk Membeli 10000 EURUSD SEDANG DILAKSANAKAN)
    • Melaksanakan Pesanan Pasaran untuk Membeli 10000 EURUSD BERJAYA, Position PID14579835
    • TradeResult (Berjaya, Position: PID14579835)
    • Posisi 14579835 dibuka pada 1.19414

  • Menggunakan ungkapan lambda

    Daripada menentukan kaedah panggilan balik bernama, anda boleh menggunakan ungkapan lambda.

    Dalam contoh berikut, apabila pesanan diletakkan, keterangan hasil akan dicetak ke log.

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

    Output Log

    • cBot "New cBot" telah dimulakan dengan jayanya untuk EURUSD, h1.
    • Meletakkan Pesanan Had untuk Membeli 10000 EURUSD (Harga: 1.19320)
    • Meletakkan Pesanan Had untuk Membeli 10000 EURUSD (Harga: 1.19320) BERJAYA, PendingOrder OID25222083
    • TradeResult (Berjaya, PendingOrder: OID25222083)

Image title