Registre d'algorithmes

Si vous disposez d'un large portefeuille d'algorithmes que vous distribuez aux utilisateurs, vous souhaiterez peut-être également proposer un panneau ou un système personnalisé permettant à ces utilisateurs de gérer facilement vos algorithmes sur leurs machines locales. Un tel système serait particulièrement utile si vous proposez plusieurs produits qui se complètent tous (par exemple, deux cBots et un indicateur personnalisé qui doivent tous être installés pour fonctionner correctement). Si un utilisateur omet d'installer un produit requis, vous pourrez l'alerter de ce fait.

De plus, lorsqu'un utilisateur a accès à de nombreux algorithmes, il peut parfois être difficile de tous les suivre. Par exemple, un utilisateur peut supprimer accidentellement un algorithme précieux pour se rendre compte plus tard qu'il ne peut plus l'utiliser.

Pour vous aider, vous et vos utilisateurs, l'API Algo expose l'interface AlgoRegistry, qui offre un moyen pratique de suivre dynamiquement les statistiques sur les algorithmes actuellement installés et désinstallés de différents types.

Travailler avec le registre d'algorithmes

Dans le AlgoRegistry, chaque algorithme est représenté par un AlgoType, qui contient le nom unique de l'algorithme et son AlgoKind (tel qu'un AlgoKind.CustomIndicator).

Vous pouvez récupérer un algorithme spécifique du registre en appelant la méthode suivante.

1

AlgoRegistry.Get(string name, AlgoKind algoKind);

Pour récupérer un nombre d'algorithmes d'un type particulier, appelez la méthode suivante.

1

AlgoRegistry.GetCount(AlgoKind algoKind)

Vous pouvez également ajouter des gestionnaires personnalisés aux événements suivants :

• AlgoTypeInstalled - déclenché chaque fois qu'un nouvel algorithme est installé.
• AlgoTypeDeleted - déclenché chaque fois qu'un nouvel algorithme est supprimé.
• AlgoTypeChanged - déclenché chaque fois qu'un algorithme installé est modifié.

Créer un exemple de plug-in

Le AlgoRegistry est parfait pour créer un plug-in qui affichera des informations sur les algorithmes directement dans l'interface utilisateur de cTrader. Le plug-in suivant fait exactement cela.

 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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

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.Plugins
{
    [Plugin(AccessRights = AccessRights.None)]
    public class AlgoStatsPlugin : Plugin
    {
        private TextBlock _customIndicatorsBlock = new TextBlock
        {
            FontSize = 12,
            FontWeight = FontWeight.Bold,
            TextAlignment = TextAlignment.Left,
            Padding = new Thickness(5, 5, 5, 5),
        };

        private TextBlock _indicatorsBlock = new TextBlock
        {
            FontSize = 12,
            FontWeight = FontWeight.Bold,
            TextAlignment = TextAlignment.Left,
            Padding = new Thickness(5, 5, 5, 5),
        };

        private TextBlock _robotsBlock = new TextBlock
        {
            FontSize = 12,
            FontWeight = FontWeight.Bold,
            TextAlignment = TextAlignment.Left,
            Padding = new Thickness(5, 5, 5, 5),
        };

        private TextBlock _pluginsBlock = new TextBlock
        {
            FontSize = 12,
            FontWeight = FontWeight.Bold,
            TextAlignment = TextAlignment.Left,
            Padding = new Thickness(5, 5, 5, 5),
        };

        private Grid _grid = new Grid(4, 1);

        protected override void OnStart()
        {
            var aspBlock = Asp.SymbolTab.AddBlock("Algo Registry");
            aspBlock.IsExpanded = true;
            aspBlock.Height = 200;

            _grid.AddChild(_robotsBlock, 0, 0);
            _grid.AddChild(_indicatorsBlock, 1, 0);
            _grid.AddChild(_customIndicatorsBlock, 2, 0);
            _grid.AddChild(_pluginsBlock, 3, 0);

            aspBlock.Child = _grid;

            Timer.Start(TimeSpan.FromSeconds(1));
        }

        protected override void OnTimer() 
        {
            _robotsBlock.Text = $"cBots: {AlgoRegistry.GetCount(AlgoKind.Robot)}";
            _customIndicatorsBlock.Text = $"Custom indicators: {AlgoRegistry.GetCount(AlgoKind.CustomIndicator)}";
            _indicatorsBlock.Text = $"Indicators: {AlgoRegistry.GetCount(AlgoKind.StandardIndicator)}";
            _pluginsBlock.Text = $"Plugins: {AlgoRegistry.GetCount(AlgoKind.Plugin)}";
        }

    }
}

Après avoir construit notre plug-in, nous devrions voir le bloc suivant dans le Panneau de symbole actif. Les données du bloc seront mises à jour dynamiquement toutes les secondes.

Installer un algorithme via un autre algorithme

L'interface AlgoRegistry permet aux développeurs de créer des algorithmes qui peuvent installer d'autres algorithmes. Par exemple, vous pouvez coder un cBot (au démarrage) pour installer automatiquement un autre cBot, un indicateur ou un plug-in.

Le cBot suivant est codé pour installer un autre 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

using System;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None, AddIndicators = true)]
    public class Installation : Robot
    {
        protected override void OnStart()
        {
            InstallationResult result = AlgoRegistry.Install("https://ctrader.com/algos/download/4392/");
            Print(result.Succeeded);
        }

        protected override void OnTick()
        {
        }

        protected override void OnStop()
        {
        }
    }
}

Résumé

AlgoRegistry est une excellente fonctionnalité pour les développeurs de plug-ins, mais elle peut également être utilisée avec d'autres types d'algorithmes. Par exemple, vous pouvez créer un indicateur qui fait référence à un autre indicateur personnalisé, auquel cas votre algorithme devrait d'abord vérifier si l'indicateur requis est installé par l'utilisateur. Nous recommandons également d'ajouter le AlgoRegistry à vos algorithmes existants pour simplifier la gestion des indicateurs personnalisés et d'autres types d'algorithmes.