Lewati ke isi

Cara bekerja dengan penyimpanan lokal

Dalam artikel ini dan video terkaitnya, kami akan menjelaskan apa itu penyimpanan lokal dan bagaimana cara menggunakannya dalam algo cTrader Anda. Kami juga akan memberikan contoh yang berguna dan menjelaskan bagaimana cakupan penyimpanan lokal bekerja.

Mengapa menggunakan penyimpanan lokal

Ada banyak kasus ketika Anda ingin algo Anda menyimpan sesuatu ke atau mengakses sesuatu dari sistem berkas lokal. Misalnya, Anda mungkin ingin menyimpan log dari semua operasi cBot. Namun, ini biasanya memerlukan algo untuk memiliki hak akses tingkat tinggi (AccessRights.FullAccess), yang kurang ideal bagi pengguna. Jika sebuah algo meminta pengguna untuk memberikan izin tingkat tinggi, pengguna jauh lebih kecil kemungkinannya untuk mempercayai algo tersebut, terutama jika didistribusikan tanpa kode sumbernya. Penyimpanan lokal adalah cara yang nyaman untuk mengakses sistem berkas lokal dengan aman tanpa menimbulkan kekhawatiran keamanan apa pun. Menggunakan penyimpanan lokal memungkinkan pengembang untuk menjaga hak akses algo mereka tetap diatur ke AccessRights.None.

Menyimpan string dalam penyimpanan lokal

Setiap jenis algo cTrader memiliki properti LocalStorage yang memungkinkan untuk menjalankan operasi baca dan tulis. Untuk mendemonstrasikan cara kerja penyimpanan lokal, kita akan membuat cBot baru. Dalam handler OnStart-nya, kita akan menggunakan metode LocalStorage.SetString(string key, string value). Seperti yang Anda lihat, metode ini membutuhkan dua argumen, yaitu kunci di mana informasi harus disimpan dan nilai yang akan disimpan.

1
LocalStorage.SetString("Message", Message);

Untuk mengambil nilai, kita akan menggunakan metode GetString(string key) dalam handler OnTick dari cBot.

1
Print(LocalStorage.GetString("Message"));

Selama Message tidak null, kita dapat membangun cBot dan melihat nilai yang diambil dicetak dengan benar dalam log.

Menyimpan objek dalam penyimpanan lokal

Selain string, Anda dapat menggunakan penyimpanan lokal untuk menyimpan berbagai jenis objek. Di balik layar, cTrader melakukan serialisasi dan deserialisasi objek dalam penyimpanan lokal yang memungkinkan untuk berbagi berbagai jenis data. Untuk mendemonstrasikan ini, kita dapat membuat kelas baru untuk menyimpan informasi, menyimpannya dan kemudian mengambilnya kembali. Kita akan menamai kelas ini Signal.

1
2
3
4
5
6
class Signal
{
    public TradeType TradeType { get; set; }
    public double SL { get; set; }
    public double TP { get; set; }
}

Dalam metode OnStart(), kita akan membuat instance baru dari kelas ini dan menginisialisasi propertinya.

1
2
3
4
5
var signal = new Signal{
    TradeType = TradeType.Sell,
    SL = 50,
    TP = 50,
};

Kita akan menggunakan metode SetObject(string key, Object object) untuk menyimpan dan mengambil saldo akun.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
protected override void OnStart()
{
    var signal = new Signal{
    TradeType = TradeType.Sell,
    SL = 50,
    TP = 50,
    };        

    LocalStorage.SetString("Message",Message);
    LocalStorage.SetObject("Signal 1", signal);
}

protected override void OnTick()
{
Print(LocalStorage.GetString("Message")); 

var signal = LocalStorage.GetObject<Signal>("Signal 1"); 
Print(signal.TradeType);
Print(signal.SL);
Print(signal.TP);
}

Jika kita membangun cBot kita dan meluncurkannya, kita seharusnya melihat nilai yang benar dicetak dalam log.

Cakupan penyimpanan lokal

Saat menggunakan penyimpanan lokal, Anda juga dapat menentukan cakupan di mana nilai yang disimpan diekspos untuk pengambilan di masa mendatang. Ada tiga cakupan berbeda yang tersedia:

  • Cakupan instance - nilai yang disimpan hanya tersedia untuk instance tertentu.
  • Cakupan tipe - nilai yang disimpan tersedia untuk semua instance dari algoritma tertentu.
  • Cakupan perangkat - nilai yang disimpan tersedia untuk semua algoritma terlepas dari jenisnya.

Berikut adalah contoh penggunaan cakupan instance.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
[Parameter()]
public bool IsWriter { get; set; }


protected override void OnStart()
{   
    if(IsWriter)
    { 
        LocalStorage.SetString("Message",Message, LocalStorageScope.Instance);
    }
}

protected override void OnTick()
{        
    if(!IsWriter)
    {
        if(LocalStorage.GetString("Message") != string.Empty)
            Print(LocalStorage.GetString("Message"));
    }
}

Perhatikan bahwa kita telah secara eksplisit menentukan cakupan dalam metode SetString().

Kita dapat menambahkan beberapa instance dari cBot ini dan mengonfigurasinya sehingga satu menulis ke penyimpanan lokal sementara yang lain mengambil informasi. Dalam kasus ini, membaca informasi seharusnya tidak mungkin. Namun, jika hanya satu instance yang diatur untuk menjalankan operasi tulis dan baca, cBot seharusnya bekerja sebagaimana mestinya.

Berikut adalah contoh penggunaan cakupan tipe.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
protected override void OnStart()
{   
    if(IsWriter)
    {             
        LocalStorage.SetString("Message",Message, LocalStorageScope.Type);
    }
}

protected override void OnTick()
{        
    if(!IsWriter)
    {
        if(LocalStorage.GetString("Message", LocalStorageScope.Type) != string.Empty)
            Print(LocalStorage.GetString("Message"));
    }
}

Jika kita membuat dua instance dari bot ini dan mengaturnya sehingga satu instance menulis ke penyimpanan lokal dan yang lain membaca nilai yang disimpan, semuanya seharusnya berjalan tanpa menimbulkan kesalahan apa pun.

Terakhir tapi tidak kalah pentingnya, cakupan perangkat memungkinkan pertukaran informasi antara algo yang berbeda. Berikut adalah contoh penggunaan jenis cakupan ini.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
protected override void OnStart()
{   
    if(IsWriter)
    {             
        LocalStorage.SetString("Message",Message, LocalStorageScope.Device);
    }
}

protected override void OnTick()
{        
    if(!IsWriter)
    {
        if(LocalStorage.GetString("Message", LocalStorageScope.Device) != string.Empty)
            Print(LocalStorage.GetString("Message"));
    }
}

Kita dapat membangun beberapa cBot yang semuanya menggunakan kode yang sama. Jika kita mengaturnya dengan benar, satu cBot dapat menyimpan informasi ke penyimpanan lokal sementara yang lain mengambilnya. Selama cakupannya sama dengan LocalStorageScope.Device, sistem kita seharusnya bekerja sebagaimana mestinya.

Menggunakan metode Flush() dan Reload()

Jika Anda ingin berbagi informasi antara beberapa instance cTrader, panggil metode Flush() dan Reload().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
protected override void OnStart()
{   
    if(IsWriter)
    {             
        LocalStorage.SetString("Message",Message, LocalStorageScope.Device);
        LocalStorage.Flush(LocalStorageScope.Device);
    }
}

protected override void OnTick()
{        
    if(!IsWriter)
    {
        LocalStorage.Reload(LocalStorageScope.Device);
        if(LocalStorage.GetString("Message", LocalStorageScope.Device) != string.Empty)
            Print(LocalStorage.GetString("Message"));
    }
}

Jika kita membangun beberapa cBot dengan kode ini dan melakukan eksperimen untuk berbagi informasi antara instance cTrader yang berbeda, kita akan melihat bahwa nilai yang kita simpan tetap ada sesuai yang diinginkan.