การเข้าถึงเครือข่าย

คู่มือนี้กำหนดวิธีการสร้างอัลกอริทึมที่สามารถเข้าถึงอินเทอร์เน็ตได้ ด้านล่างนี้คือสรุปหนึ่งนาทีของคุณสมบัติ API นี้

HTTP

อินเทอร์เฟซ Http ใหม่มีหลายเมธอดที่เมื่อนำไปใช้ ควรช่วยให้ cBot และอัลกอริทึมประเภทอื่น ๆ สามารถเข้าถึงอินเทอร์เน็ตได้ สำหรับตัวอย่าง ดูดังต่อไปนี้:

• HttpResponse Http.Get(string uri) ทำคำขอ GET ไปยัง URI ที่ระบุในสตริง uri ที่ส่งผ่านและส่งคืนวัตถุ HttpsResponse ที่มีผลลัพธ์ของคำขอนี้

คลาส HttpsRequest ช่วยให้สามารถทำคำขอที่ซับซ้อนขึ้นรวมถึงคำขอ POST ในการทำคำขอเหล่านี้ ให้ตั้งค่าคุณสมบัติ HttpsRequest.Method เป็นหนึ่งในค่าของ enum HttpMethod เช่น HttpMethod.Put หรือ HttpMethod.Patch

ในทางกลับกัน คุณสมบัติ HttpsRequest.Uri มี URI ที่ส่งคำขอไป ในขณะที่คุณสมบัติ HttpsRequest.Body สามารถใช้เพื่อตั้งค่าเนื้อหาของคำขอ ดูด้านล่างสำหรับตัวอย่างวิธีการใช้วัตถุ HttpsRequest

• HttpResponse Http.Send(HttpRequest request) ทำคำขอไปยัง URI ที่ระบุเป็นค่าของคุณสมบัติ request.Uri ของวัตถุ HttpsRequest ที่ส่งผ่านเข้ามาในเมธอดนี้ หลังจากนั้น ส่งคืนวัตถุ HttpsResponse ที่มีผลลัพธ์ของคำขอนี้ ประเภทของคำขอถูกตั้งค่าเป็นค่าของคุณสมบัติ equest.Method

สร้าง cBot ตัวอย่าง

ทำคำขอ GET

เราจะสร้าง cBot อย่างง่ายที่ทำการดำเนินการต่อไปนี้:

• ส่งคำขอ GET และเข้าถึงไฟล์ JSON ผ่าน API ที่ https://forexApiExample.com/v1/exchangerate (โปรดทราบว่า API นี้เป็นเพียงตัวอย่างที่สมมติขึ้น)
• หากการตอบสนอง GET สำเร็จ cBot จะแปลงเนื้อหาของการตอบสนองเป็นวัตถุของคลาส SymbolPrice ที่กำหนดเอง (เราได้สร้างคลาสนี้ขึ้นเพื่อการสาธิต)
• ส่งคำสั่งขาย Limit สำหรับสัญลักษณ์ที่ราคาสูงกว่าราคาที่ระบุใน API เล็กน้อย

โปรดทราบว่า cBot นี้เป็นเพียงตัวอย่างที่สมมติขึ้นทั้งหมด แม้ว่าโค้ดจะสร้างได้ แต่จะไม่ทำการดำเนินการที่มีความหมายใด ๆ

นี่คือโค้ดของ cBot ตัวอย่างของเรา:

 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
26
27
28
29
30
31
32
33
34
35
36
37

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class NetworkAccessTest : Robot
    {

        protected override void OnStart()
        {

            var responseToGet = Http.Get("https://forexApiExample.com/v1/exchangerate");

            if (responseToGet.IsSuccessful)
            {
                var tradedSymbol = JsonSerializer.Deserialize<SymbolPrice>(responseToGet.Body);
                var result = PlaceLimitOrder(TradeType.Sell, tradedSymbol.SymbolName, 10000, tradedSymbol.ConversionRate + 0.15);

            }
        }
    }

    public class SymbolPrice
    {
        public string SymbolName { get; set; }
        public double ConversionRate { get; set; }
    }
}

หาก cBot นี้เข้าถึง API จริง มันจะทำได้สำเร็จ

ทำคำขอ POST

เราสามารถสร้าง cBot ที่ซับซ้อนขึ้นซึ่งบรรลุเป้าหมายต่อไปนี้:

• ส่งคำขอ POST ไปยัง API จำลองเดียวกันที่ https://anotherForexApiExample.com/commodities/v1/getaccesstoken สิ่งนี้ทำเพื่อรับโทเค็นการเข้าถึงสำหรับ API นี้
• เก็บโทเค็นจากเนื้อหาการตอบสนองในตัวแปร token
• ทำคำขอ GET ไปยัง API เดียวกันโดยส่งค่าของตัวแปร token เป็นพารามิเตอร์คิวรีใน URI (https://anotherForexApiExample.com/commodities/v1/getprices)
• ใช้การแปลง JSON (ที่กล่าวถึงข้างต้น) ส่งคำสั่งซื้อ Stop ที่ราคาต่ำกว่าราคาที่ได้รับจาก API เล็กน้อย

อีกครั้ง โปรดทราบว่า cBot นี้จะไม่ทำการดำเนินการที่มีความหมายใด ๆ เมื่อคอมไพล์ มันมีไว้เพื่อเป็นตัวอย่างเท่านั้น

 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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class NetworkAccessTestTwo : Robot
    {

        protected override void OnStart()
        {
            var uriForAccessToken = new Uri("https://anotherForexApiExample.com/commodities/v1/getaccesstoken");

            var postRequest = new HttpRequest(uriForAccessToken);

            postRequest.Method = HttpMethod.Post;

            var responseToPost = Http.Send(postRequest);

            var token = responseToPost.Body;

            var response = Http.Get($"https://anotherForexApiExample.com/commodities/v1/getprices?token={token}");

            if (response.IsSuccessful)
            {
                var tradedSymbol = JsonSerializer.Deserialize<SymbolPrice>(response.Body);

                var result = PlaceStopOrder(TradeType.Buy, tradedSymbol.SymbolName, 10000, tradedSymbol.ConversionRate - 0.15);

            }
        }
    }

    public class SymbolPrice
    {
        public string SymbolName { get; set; }
        public double ConversionRate { get; set; }
    }
}

ไคลเอนต์ WebSocket

Algo API อนุญาตให้ทุกคนใช้บริการเว็บและทรัพยากรต่างๆ ผ่านการเชื่อมต่อ websocket เมื่อเทียบกับโปรโตคอล HTTP ที่ใช้ในฟีเจอร์การเข้าถึงเครือข่าย โปรโตคอล WebSocket นั้นเร็วกว่าและอนุญาตให้รับข้อมูลแบบเรียลไทม์

การใช้ไคลเอนต์ WebSocket

การใช้ไคลเอนต์ WebSocket นั้นง่าย:

1. เลือกบริการที่เปิดเผยจุดสิ้นสุดสำหรับการเชื่อมต่อ websocket
2. เริ่มต้นออบเจ็กต์ของคลาส WebSocketClientOptions และระบุพารามิเตอร์เพื่อกำหนดค่าไคลเอนต์ของคุณ
3. เริ่มต้นออบเจ็กต์ของคลาส WebSocketClient และส่งตัวเลือกที่สร้างไว้ก่อนหน้านี้ไปยังคอนสตรักเตอร์
4. ใช้เมธอด Connect() เพื่อเชื่อมต่อกับทรัพยากรที่คุณเลือกและส่งข้อมูลผ่านเมธอด Send()
5. ใช้ตัวจัดการเหตุการณ์ TextReceived() และ BinaryReceived() เพื่อกำหนดสิ่งที่ algo ของคุณควรทำเมื่อไคลเอนต์ WebSocket ได้รับข้อมูลใหม่

ด้านล่างนี้ เราจะสร้าง cBot อย่างง่ายที่เชื่อมต่อกับบริการข่าวเศรษฐกิจสมมติผ่าน websocket เมื่อมีข่าวใหม่เกี่ยวกับสัญลักษณ์ที่ cBot กำลังเชื่อมต่ออยู่ในปัจจุบัน algo จะแสดงกล่องข้อความที่มีเนื้อหาข่าว

 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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class ExampleWebSocketBot : Robot
    {

        private static WebSocketClientOptions _webSocketClientOptions = new WebSocketClientOptions 
        {
            KeepAliveInterval = new TimeSpan(0, 1, 30),
            UseDefaultCredentials = true,
        };
        private WebSocketClient _webSocketClient = new WebSocketClient(_webSocketClientOptions);
        private readonly Uri _targetUri = new Uri("ws://amazingnews.com:8000");

        protected override void OnStart()
        {
            _webSocketClient.Connect(_targetUri);
            _webSocketClient.Send("Hello");
            _webSocketClient.TextReceived += NewsReceived;
        }

        protected override void OnStop()
        {
            _webSocketClient.Close(WebSocketClientCloseStatus.NormalClosure);
        }

        private void NewsReceived(WebSocketClientTextReceivedEventArgs args) 
        {
            if (args.Text.Contains(SymbolName)) 
            {
                MessageBox.Show(args.Text, "News!", MessageBoxButton.OK, MessageBoxImage.Information, MessageBoxResult.OK);
            }
        }
    }
}

ดังที่คุณเห็น โค้ดของเรากะทัดรัดมากเนื่องจากเราสามารถจัดการเหตุการณ์ WebSocketClient.TextReceived เพื่อแสดงกล่องข้อความได้ โปรดทราบว่า cBot ของเราไม่ได้ร้องขอข้อมูลจากบริการอย่างแข็งขัน แต่ตอบสนองต่อข้อมูลใหม่ที่ส่งมาให้แบบไดนามิก

ประโยชน์ของ WebSocket

เนื่องจาก websocket อนุญาตให้ตอบสนองต่อข้อมูลใหม่จากเว็บแบบเรียลไทม์ จึงเหมาะอย่างยิ่งสำหรับการรวมกับบริการของบุคคลที่สามที่สามารถแจ้งเตือน algo ของคุณเกี่ยวกับบางสิ่งได้โดยอัตโนมัติ ต่อไปนี้คือตัวอย่างบางส่วนของทรัพยากรเว็บที่คุณสามารถใช้ไคลเอนต์ WebSocket ได้

• ปฏิทินข่าวเศรษฐกิจ เมื่อมีการเผยแพร่ข่าวใหม่ algo ของคุณสามารถแสดงกล่องข้อความพร้อมข้อมูลสำคัญได้
• บริการ AI แบบสร้างสรรค์ เมื่อบริการ AI เริ่มให้การตอบสนองต่อคำสั่ง คุณสามารถแสดงผลลัพธ์ทีละคำแทนที่จะต้องรอการตอบสนองที่สมบูรณ์
• สตรีมราคาสำหรับสัญลักษณ์ทั้งหมดที่สัมพันธ์กับสัญลักษณ์ที่ algo เชื่อมต่ออยู่ เมื่อมีการอัปเดตราคา จะแสดงให้ผู้ใช้ algo เห็นทันทีและแม่นยำ
• เครือข่ายสื่อสังคมที่มุ่งเน้นการเทรด เมื่อมีการโพสต์ข้อความใหม่เกี่ยวกับสัญลักษณ์เฉพาะ algo สามารถแสดงเนื้อหาให้ผู้ใช้เห็นได้

โดยทั่วไป การเชื่อมต่อ websocket มีข้อดีดังต่อไปนี้เมื่อเทียบกับ HTTPS ปกติ:

• การเชื่อมต่อ WebSocket มีประสิทธิภาพมากกว่า คำขอ HTTP ใดๆ ต้องมีข้อมูลเพิ่มเติม เช่น ส่วนหัว ด้วย websocket การเชื่อมต่อของคุณจะถูกสร้างขึ้นเพียงครั้งเดียว หลังจากนั้นไม่จำเป็นต้องส่งข้อมูลที่ซ้ำซ้อน
• การเชื่อมต่อ WebSocket มีการทำงานพร้อมกันที่ดีขึ้น ไม่จำเป็นต้องหยุดการทำงานของ algo จนกว่าคุณจะรอการตอบสนองหลังจากส่งคำขอ HTTP ด้วย websocket คุณสามารถส่งและรับข้อมูลได้ตลอดเวลาและจัดการแบบอะซิงโครนัส

ไคลเอนต์ WebSocket อนุญาตให้ algo ทุกประเภทโต้ตอบกับทรัพยากรเว็บแบบไดนามิก การโต้ตอบนี้เร็วกว่าและมีประสิทธิภาพมากกว่าเมื่อเทียบกับการใช้ HTTP ใช้ไคลเอนต์ WebSocket เพื่อสร้าง algo ที่ทรงพลังซึ่งรวมกับบริการของบุคคลที่สาม

การเข้าถึงเครือข่ายและคุณสมบัติ AccessRights

โดยสรุป enum AccessRights กำหนดว่าอัลกอริทึมมีสิทธิ์เข้าถึงข้อมูลภายนอก cTrader เช่น ระบบไฟล์ของเครื่องคอมพิวเตอร์ของคุณหรือไม่ คุณสามารถเรียนรู้เพิ่มเติมได้ในบทช่วยสอนนี้

การตั้งค่า AccessRights เป็น AccessRights.FullAccess อนุญาตให้ algo ดำเนินการขั้นสูง (เช่น การดึงข้อมูลจากรีจิสทรีของ Windows) อย่างไรก็ตาม ผู้ใช้ปลายทางอาจพบว่าการให้สิทธิ์เต็มแก่ cBot หรืออินดิเคเตอร์นั้นมีความเสี่ยงเนื่องจากอาจนำไปสู่การรั่วไหลของข้อมูล

ดังนั้น AccessRights.None จึงมักเป็นตัวเลือกที่เหมาะสมที่สุดหากคุณต้องการแชร์ผลิตภัณฑ์ algo ของคุณกับผู้อื่น อย่างไรก็ตาม แม้ว่าคุณจะเลือกตัวเลือกนี้ ผลิตภัณฑ์ cTrader ของคุณก็สามารถเข้าถึงเว็บได้อย่างอิสระ การเพิ่มฟังก์ชันการเข้าถึงเครือข่ายใน cTrader Algo API หมายความว่า cBot ไม่จำเป็นต้องตั้งค่าคุณสมบัติ AccessRights เป็น AccessRights.FullAccess อีกต่อไปเพื่อทำงานกับทรัพยากรบนอินเทอร์เน็ต

สิ่งนี้ขยายโอกาสอย่างมากสำหรับนักพัฒนา algo เมื่อเขียนโค้ดผลิตภัณฑ์ cTrader ที่พวกเขาตั้งใจจะแจกจ่ายให้กับนักเทรดคนอื่นๆ

สรุป

โดยสรุป การเข้าถึงเครือข่ายเป็นฟีเจอร์ที่ทรงพลังซึ่งช่วยขยายจำนวนการดำเนินการที่อัลกอริทึมของคุณสามารถทำได้อย่างมาก โดยไม่ก่อให้เกิดความเสี่ยงเพิ่มเติม