Création d'une API "intermédiaire"

Bonjour,

J’aimerais savoir s’il est possible de créer une API intermédiaire.
Ce que j’entends par la, c’est que j’ai deux logiciels qui ont une API différentes mais ces logiciels ont des fonctionnalités en commun.

Par exemple, pour ouvrir un document l’un des logiciels pourrait avoir une fonction comme celle-ci:

AppLogiciel1.OpenDoc(param1, param2);

et l’autre logiciel un appel comme celui-ci:

instanceApp.Open(param1);

Pourrais-je créer une API avec un appel tel que Open(params...) qui ferais un appel sur la bonne API.

Cela me permettrais en outre de développer un complément unique pour deux logiciels différents. Mes problèmes sont pour savoir comment je pourrais définir quelle API utilisé et comment implémenter cela ?

Ma question est portée pour une implémentation en C#.

Je vous remercie.

Salut,

Pour éviter ce type de problème: pourrais-tu expliquer ce que tu souhaites implémenter exactement ?

Le polymorphisme semble être une solution, mais quel est ton besoin précisément ?

edit: @WinXaito, j’ai rajouté la fiche wikipédia abordant le polymorphisme en programmation. Les exemples sont plutôt clairs.

Alors je ne sais pas exactement ce que je veux faire, la je suis surtout en recherche de solution pour voir ce qui m’intéresserait.

En l’occurence, ce serait pour combiner les APIs de SolidWorks et de Autodesk Inventor (il s’agit de deux logiciels de modélisation 3D.

Je connais bien l’API de SolidWorks mais encore pas suffisamment celle de Inventor pour voir si cela vaudrait la peine (je ne sais pas ce qu’il est possible de faire avec l’API de Inventor).

Je vais voir si le Polymorphisme pourrais m’être utile.

Merci !

Bonjour WinXaito,

J’ai souvent ce type de problème. Typiquement pour les emails afin d’utiliser soit le protocole SMTP classique soit Mailjet.

Démonstration:

class MailManager {
  constructor () {
    this.smtp = null; // instance SMTP
    this.mailjet = null; // instance Mailjet
    this.mode = 'smtp'; // mode de basculement standard
  }

  // Fonction de dispatch avec personnalisation du mode d'envoi
  sendMail (args, mode=this.mode) {
    if(mode === 'smtp') {
      this.sendMailWithSmtp(args);
    } else if(mode === 'mailjet') {
      this.sendMailWithMailjet(args);
  }

  // envoyer l'email via le SMTP
  sendMailWithSmtp (args) {
    this.smtp.send(args);
  }

  // envoyer l'email via Mailjet
  sendMailWithMailjet (args) {
    this.mailjet.send(args);
  }

  /*
   * SETTERS
   */

  setSmtpConf (options) {
    this.smtp = new SmtpApi(options);
    this.setMode('smtp');
  }

  setMailjetConf (options) {
    this.mailjet = new MailjetApi(options);
    this.setMode('mailjet');
  }

  setMode (mode='smtp') {
    this.mode = mode === 'mailjet' ? 'mailjet' : 'smtp';
  }
}

/* Exemple */
let clientMail = new MailManager();
clientMail.setMailjetConf({ user: '123', pass: '456' });
clientMail.sendMail(['toto@gmail.com', 'Hello man !']);

Evidemment ça peut s’adapter à toutes les situations. A partir de 3–4 appels différents, je te conseille de mettre plutôt un switch dans ta fonction de dispatch (ici sendMail) - ce sera plus lisible.

Cette méthode toutefois n’a aucune utilité si tu injectes directement ton instance ; le polymorphisme répond très bien au problème !