Discussion :

[Nasire]

Bonjour,
je souhaiterais concevoir un programme extensible mais je ne parvient pas trouver un outil adéquat.

J'ai développer en C la base de mon application qui sera fixe à l'exception d'une (voir plusieurs) fonction(s) qui seraient vouées à évoluer.
Je m'explique :
mon programme cherche à déterminer des systèmes de trading qui permet d'investir intelligemment sur le marché. Pour ce faire, je dois à un moment calculer certaines valeurs d'indicateurs. Seul petit problème, il existe des centaines d'indicateurs et tous les implémenter serait une perte de temps d'autant que ce n'est pas la valeur ajoutée de mon logiciel projeté, et que d'autres le font très bien.
L'idée serait donc de proposer au client d'implémenter lui même ces indicateurs.

Désolé de vous donner autant de détails mais mon problème est pointue et j'ai des exigences particulières :

- pas de re-compilation possible
- chargement à la volée, sans redémarrer l’application si possible
- l'outil doit être accessible à des non programmeurs, je voudrais éviter de leur demander d'écrire tout le fichier, mais uniquement la partie "utile"
- un choix assez large de langages (en évitant le C)
- "professionnel" : pas de scripts ou de machins bidules, une interface avec saisie du nom et du corps de l'indicateur, puis un bouton de soumission

Je suis exigeant, je sais, mais des concurrents proposent des fonctionnalités similaires... comment ont-ils fait, je l'ignore!

Mes recherches m'ont conduit à deux résultats proche de ce que je veux sans pour autant me satisfaire.

En java, il est possible de charge dynamiquement un code contenu dans une chaîne de caractère. Le hic c'est que cela ne marche qu'avec du java! (pas moyen de charger un code en C par exemple)

En .net, il est possible de créer des assembly puis de les charger dans l'appdomaine que l'on souhaite. Grâce au runtime de Microsoft plusieurs langages sont pris en compte. Mais là je me pose alors plusieurs questions :
- comment faire le pont entre mon programme en C, que je souhaite être compilé statiquement pour des questions de confidentialité et les DLL chargés à la volées?
- comment créer ces dites assembly efficacement avec juste la partie utile?
- le chargement peut-il se faire sans redémarrer l'application?

L'utilisation de ces librairies est-elle la méthode la plus adapté à mon problème?
Plus généralement, y a-t-il d'autres outils pour répondre à mes besoins?

J'ai essayé de faire court, si vous voulez d'avantage de renseignements, n'hésitez pas!

J'attends une réponse détaillé car je me suis déjà fait une idée sur la question mais j'ai besoin de précisions pour passer à l'implémentation.
Merci d'avance pour tout réponse,
Nasire.
Ingénieur en systèmes d'informations.

[CinePhil]

J'ai travaillé à l'INRA sur un logiciel permettant de faire des calculs statistiques sur des données massives et géocodées et d'en afficher le résultat sur la carte de France.

La formule de calcul de l'indicateur statistique était établie par le statisticien sur une interface qui proposait l'utilisation d'opérations élémentaires :
- les 4 opérations de base + - x / ;
- moyenne, somme, comptage ;
- recherche de quantiles, de minimums, de maximums, de médiane ;
- calculs intermédiaires et réutilisation de ceux-ci dans la formule globale.

Tous les indicateurs sont ensuite stockés dans une base de données de projet d'étude.

L'ensemble est développé en PHP avec des données sous MySQL mais le principe est, je pense, adaptable à n'importe quel langage.

Dans ton cas, si un indicateur est une formule relativement complexe mais basée sur quelques opérations plus simples, tu pourrais adopter le même principe en ne développant que les opérations de base et en laissant l'utilisateur établir les formules complexes à l'aide de celles-ci.

[Nasire]

Pas vraiment.
Les calculs d'indicateurs sont simples.
On dispose de six doubles (réels) :
prix d'ouverture, de fermeture, le plus haut, le plus bas, volume et date.
Le calcul se fait sur une certaine durée : on a donc en fait 6 tableaux de doubles (de taille N).
A l'instant i on peut calculer l'indicateur de manière simple :
indic[i] = open[i] - close[i] (par exemple)
La seule contrainte est de ne pas utiliser les données après i (sinon on triche, on ne simule plus du temps réel)

A la base l'application proposera disons les 10 indicateurs les plus utiles.
Après, je souhaiterais donner la liberté au client d'en créer d'autres très simplement.
Par exemple, s'il écrit indic[i] = open[i] - close[i], le programme devrait générer la fonction (syntaxe C)

void indic_exemple(DataPrice *dp, Indic **indic){

for(uint32_t i = 0; i < dp.size; i++)

(*indic)[i] = dp->open[i] - dp->close[i];

}

Ensuite la fonction devra être intégré au programme pour qu'il puisse s'en servir.

Ici je ne cite qu'un exemple parmi tant d'autres.
J'ai bien étudié la situation, le plus simple serait vraiment de créer des librairies à charger dynamiquement.
Sauf que la tâche s'avère plus délicate que prévu :

- mon programme est en C pour des questions de performance (sinon j'aurais pu le faire en C# par exemple) et je souhaite l’exécuter dans un environnement .net avec compilation statique;
- je souhaite pouvoir créer les librairies en complétant une partie du programme (comme ça l'utilisateur ne mettra que l'essentiel)
- je vous demande de l'aide pour la création et le chargement dynamique de librairie car les différents documents que j'ai trouvé n'explique pas assez en détails : la librairie est supposé déjà crée et le code fournie est difficilement adaptable!

Je reformule donc mon problème :
je dispose d'un type de fonction bien définie en quantité que je souhaite pouvoir varier.
mon programme est compilé avec un nombre initial de ces fonctions.
Comment faire pour en créer d'autres dynamiquement et pour les invoquer dans mon programme central?

[wiztricks]

Salut,

je dispose d'un type de fonction bien définie en quantité que je souhaite pouvoir varier.
mon programme est compilé avec un nombre initial de ces fonctions.
Comment faire pour en créer d'autres dynamiquement et pour les invoquer dans mon programme central?

En gros, on a un programme principal qui doit s'interfacer avec des plugins arbitraire (ceux définis dans le sous-répertoire .plugins par exemple).

Ensuite il faut pouvoir appeler la fonction "indic_exemple" depuis le programme principal. Le plus simple sera de passer par un proxy qui sérialise l'appel.

Plutôt que d'écrire: indic_exemple(...) on écrira call('indic_exemple',...)
Ce qui revient à faire du RPC "in process" avec un peu d'introspection pour récupérer les informations sur ce que contient la DLL.

L'architecture "high level" est PROG <==> PROXY 1 <==>* DLLs

Le boulot est dans les "<==>" mais il faut arbitrer entre mise en œuvre d'un truc nécessairement compliqué (XML-RPC, COM, introspection Java/C#/...) car traitant le cas général et la construction d'une API spécifique car le nombre de cas de figures est "petit".

Comme vous travailler en C, aller voir un peu dans le forum adhoc s'ils ont quelques idées sur le "comment" réaliser cela simplement dans ce cas.

- W

[Nasire]

Plutôt que d'écrire: indic_exemple(...) on écrira call('indic_exemple',...)
Ce qui revient à faire du RPC "in process" avec un peu d'introspection pour récupérer les informations sur ce que contient la DLL.

L'architecture "high level" est PROG <==> PROXY 1 <==>* DLLs

salut,
je pense que tu as bien résumé le problème

Le boulot est dans les "<==>" mais il faut arbitrer entre mise en œuvre d'un truc nécessairement compliqué (XML-RPC, COM, introspection Java/C#/...) car traitant le cas général et la construction d'une API spécifique car le nombre de cas de figures est "petit".

En effet, et j'ai déjà cherché à mettre en oeuvre cette architecture sans réellement y parvenir.

A priori le proxy est en .net (ce n'est pas un langage je sais, mais c'est pour dire un des langages managés du genre C#, VB ou autre)

1. PROG (en C) => PROXY (en .net) :
   comment intégrer du code C compilé statiquement en .net?
   (je vois comment faire quand le code n'est pas compilé car le .net gère le C et le compile à la volée; Mais pour des raisons de confidentialité je le veux compilé statiquement)
   
   
2. PROG (en C) <= PROXY (en .net) :
   comment depuis du C récupérer des données du .net ?
   (je pourrais aller voir du côté adhoc mais vu que le problème n'est pas isolé, j'espère avoir une réponse qui tient compte du contexte)
   en particulier je dois récupérer les données de la DDL qui a été chargé
   
   
3. PROXY (en .net) <= *DLL
   le choix du proxy en .net a été fait pour pouvoir intégrer des DLLs écrites en divers langages managés (C#, VB, ...)
   Mais comment faire concrètement pour y parvenir?
   (j'ai trouvé un tuto en VB qui charge une DLL écrite en VB, mais je ne sais pas comment créer ces dites DLLs et surtout comment faire pour prendre en compte des DLLs écrites en C# par exemple)
   Cette question peut paraître étrange, mais par expérience je sais que les clients souhaiteraient avoir le choix des langages pour écrire leur DLLs (et en plus d'autres logiciels le font déjà)
   
   
4. PROXY (en .net) => *DLL
   je n'ai pas vraiment réfléchi à ce sens là,
   mais je pense qu 'hormis les messages visant à vérifier la compatibilité de la DLL, il n'y a rien à faire?

Voilà, le problème est complexe.
J'ai un peu étudié les sous-problèmes chacun à part mais j'ai du mal à recoudre les solutions entre elles pour parvenir à une solution globale cohérente.

Dernière précision :
je ne connais pas vraiment les avantages et inconvénients entre APIs et introspection (la solution proposée dans le tuto que j'ai vu)
Opter pour une API supposerait que l'on ai "formaté" la fonction à importer?
C'est ce qui paraît être mon cas, car comme je l'ai déjà dit, le client n'écrira que la partie utile et un petit programme annexe s'occupera de compléter avec le reste (mettre l'entête de la fonction, itérer de 0 à N...) et créera la DLL associée.

Merci d'avance pour toute réponse, de préférence assez précise!

[wiztricks]

A priori le proxy est en .net (ce n'est pas un langage je sais, mais c'est pour dire un des langages managés du genre C#, VB ou autre)
....
Mais comment faire concrètement pour y parvenir?

.NET c'est une évolution de COM/OLE qui est une variante de XML/RPC Corba.
L'architecture et les fonctions sont les mêmes.

Ce qui change, c'est la documentation à lire/comprendre/tester pour réaliser la chose.
Ce qui pourraient vous aider traînent plutôt dans les forums .NET.
note: hier, je disais C parce que je n'avais pas compris que vous aviez choisi la techno du proxy... Mon propos est juste de vous sensibiliser que ceux qui pourraient éventuellement vous aider traînent rarement ici...

- W