Modèle de module – Wikipedia wiki

Posted on by
before-content-x4

Modèle de conception logicielle

after-content-x4

En génie logiciel, le modèle de module est un modèle de conception utilisé pour implémenter le concept de modules logiciels, défini par la programmation modulaire, dans un langage de programmation avec une prise en charge directe incomplète pour le concept.

Ce modèle peut être mis en œuvre de plusieurs manières en fonction du langage de programmation hôte, tel que le modèle de conception Singleton, des membres statiques orientés objet dans une classe et une procédure globale. Dans Python, le motif est intégré dans la langue, et chaque fichier .py est automatiquement un module. Il en va de même pour ADA, où le package peut être considéré comme un module (similaire à une classe statique).

Définition et structure [ modifier ]]

Le modèle de conception du logiciel de module Fournit les caractéristiques et la structure syntaxique définie par le paradigme de programmation modulaire aux langages de programmation qui ont un support incomplet du concept.

The object module pattern expressed in UML.

Le motif du module d’objet exprimé en UML.

Concept [ modifier ]]

Dans le développement de logiciels, le code source peut être organisé en composants qui accomplissent une fonction particulière ou contiennent tout ce qui est nécessaire pour accomplir une tâche particulière. La programmation modulaire est l’une de ces approches.

after-content-x4

Le concept d’un “module” n’est pas entièrement pris en charge dans de nombreux langages de programmation courants.

Caractéristiques [ modifier ]]

Afin de considérer qu’un singleton ou tout groupe de code connexe implémente ce modèle, les fonctionnalités suivantes doivent être fournies:

  • Une partie du code doit avoir un accès global ou publique et être conçue pour une utilisation comme code global / public. Un code privé ou protégé supplémentaire peut être exécuté par le code public principal.
  • Un module doit avoir une fonction d’initialisateur qui équivaut à ou complémentaire à une méthode de constructeur d’objets. Cette fonctionnalité n’est pas prise en charge par des espaces de noms réguliers.
  • Un module doit avoir une fonction Finalizer qui équivaut à ou complémentaire à une méthode de destructeur d’objet. Cette fonctionnalité n’est pas prise en charge par des espaces de noms réguliers.
  • Les membres à l’appui peuvent nécessiter un code d’initialisation / finalisation qui est exécuté par la fonction initialisateur / finalisateur du module.
  • La plupart des membres sont des fonctions qui effectuent des opérations sur des éléments externes à la classe, fournis comme arguments en appelant des fonctions. Ces fonctions sont des “utilitaires”, “outils” ou “bibliothèques”.

Implémentations [ modifier ]]

La sémantique et la syntaxe de chaque langage de programmation peuvent affecter la mise en œuvre de ce modèle.

Langages de programmation orientés objet [ modifier ]]

Java [ modifier ]]

Bien que Java soutient la notion de espace de noms , une version réduite d’un module, certains scénarios bénéficient de l’utilisation du modèle de conception au lieu d’utiliser des espaces de noms.

L’exemple suivant utilise le modèle singleton.

Définition [ modifier ]] 
emballer  consoles ;  importer  java.io.inputstream ;  importer  java.io.printstream ;  public  final  classe  Module principal  {  privé  statique  Module principal  singleton  =  nul ;  public  Flux d'entrée  saisir  =  nul ;  public  Accumulé  sortir  =  nul ;  public  Accumulé  erreur  =  nul ;  privé  Module principal ()  {  // ne fait rien exprès !!!  }  // ...  public  statique  Module principal  Gettingleton ()  {  si  ( Module principal . singleton  ==  nul )  {  Module principal . singleton  =  nouveau  Module principal ();  }  retour  Module principal . singleton ;  }  // ...  public  annuler  préparer ()  {  //System.out.println ("Consoles :: Prepare ();");  ce . saisir  =  nouveau  Flux d'entrée ();  ce . sortir  =  nouveau  Accumulé ();  ce . erreur  =  nouveau  Accumulé ();  }  public  annuler  sans préchauffer ()  {  ce . sortir  =  nul ;  ce . saisir  =  nul ;  ce . erreur  =  nul ;  //System.out.println ("Consoles :: Unprepare ();");  }  // ...  public  annuler  imprimer ()  {  Système . dehors . println ();  }  public  annuler  imprimé ( Chaîne  valeur )  {  Système . dehors . imprimer ( valeur ));  }  public  annuler  printInteger ( int  valeur )  {  Système . dehors . imprimer ( valeur ));  }  public  annuler  printboolean ( booléen  valeur )  {  Système . dehors . imprimer ( valeur ));  }  public  annuler  scannewline ()  {  // faire: ...  }  public  annuler  scandrage ( Chaîne  valeur )  {  // faire: ...  }  public  annuler  scannentier ( int  valeur )  {  // faire: ...  }  public  annuler  scanboolean ( booléen  valeur )  {  // faire: ...  }  // ...  }
Mise en œuvre [ modifier ]] 
importer  consoles. * ;  classe  Consolemo  {  public  statique  Module principal  console  =  nul ;  public  statique  annuler  préparer ()  {  console  =  Module principal . Gettingleton ();  console . préparer ();  }  public  statique  annuler  sans préchauffer ()  {  console . sans préchauffer ();  }  public  statique  annuler  exécuter ( Chaîne []  args )  {  console . imprimé ( "Bonjour le monde" ));  console . imprimer ();  console . scannewline ();  }  public  statique  annuler  principal ( Chaîne []  args )  {  préparer ();  exécuter ( args ));  sans préchauffer ();  }  }

C # (C Sharp .NET) [ modifier ]]

C #, comme Java, prend en charge les espaces de noms bien que le modèle reste utile dans des cas spécifiques.

L’exemple suivant utilise le modèle singleton.

Définition [ modifier ]] 
en utilisant  Système ;  en utilisant  System.io ;  en utilisant  System.Text ;  espace de noms  Consoles ;  public  scellé  classe  Module principal  {   privé  statique  Module principal  Singleton  =  nul ;      public InputStream input = null;
    public OutputStream output = null;
    public ErrorStream error = null;

    // ...

    public MainModule()
    {
        // does nothing on purpose !!!
    }

    // ...

    public static MainModule GetSingleton()
    {
        if (MainModule.Singleton == null)
        {
            MainModule.Singleton = new MainModule();
        }

        return MainModule.Singleton;
    }

    // ...

    public void Prepare()
    {
        //System.WriteLine("console::prepare();");

        this.input = new InputStream();
        this.output = new OutputStream();
        this.error = new ErrorStream();
    }

    public void Unprepare()
    {
        this.output = null;
        this.input = null;
        this.error = null;

        //System.WriteLine("console::unprepare();");
    }

    // ...

    public void PrintNewLine()
    {
        System.Console.WriteLine("");
    }

    public void PrintString(String Value)
    {
        System.Console.Write(Value);
    }

    public void PrintInteger(Integer Value)
    {
        System.Console.Write(Value);
    }

    public void PrintBoolean(Boolean Value)
    {
        System.Console.Write(Value);
    }

    public void ScanNewLine()
    {
        // to-do: ...
    }

    public void ScanString(String Value)
    {
        // to-do: ...
    }

    public void ScanInteger(Integer Value)
    {
        // to-do: ...
    }

    public void ScanBoolean(Boolean Value)
    {
        // to-do: ...
    }

    // ...
}
Mise en œuvre [ modifier ]] 
classe  Consolemo  {   public  statique  Consoles . Module principal  Console  =  nul ;   public  statique  annuler  Préparer ()   {   Console  =  Consoles . Module principal . Gettingleton ();   Console . Préparer ();      }

    public static void Unprepare()
    {
        Console.Unprepare();
    }

    public static void Execute()
    {
        Console.PrintString("Hello World");
        Console.PrintNewLine();
        Console.ScanNewLine();
    }

    public static void Main()
    {
        Prepare();
        Execute(args);
        Unprepare();
    }
}

Langages de programmation basés sur un prototype [ modifier ]]

Javascrip [ modifier ]]

JavaScript est couramment utilisé pour automatiser les pages Web.

Définition [ modifier ]] 
fonction  Consoleclass ()  {  était  Saisir  =  nul ;  était  Sortir  =  nul ;  était  Erreur  =  nul ;  // ...  ce . préparer  =  fonction ()  {  ce . Saisir  =  nouveau  Flux d'entrée ();  ce . Sortir  =  nouveau  Sortie de sortie ();  ce . Erreur  =  nouveau  Errortream ();  }  ce . sans préchauffer  =  fonction ()  {  ce . Saisir  =  nul ;  ce . Sortir  =  nul ;  ce . Erreur  =  nul ;  }  // ...  était  imprimer  =  fonction ()  {  // code qui imprime une nouvelle ligne  }  était  imprimé  =  fonction ( paramètres )  {  // code qui imprime les paramètres  }  était  printInteger  =  fonction ( paramètres )  {  // code qui imprime les paramètres  }  était  printboolean  =  fonction ( paramètres )  {  // code qui imprime les paramètres  }  était  Scannewline  =  fonction ()  {  // code qui recherche une nouvelle ligne  }  était  Scandrage  =  fonction ( paramètres )  {  // code qui saisit les données dans les paramètres  }  était  Scannentier  =  fonction ( paramètres )  {  // code qui saisit les données dans les paramètres  }  était  Scanboolean  =  fonction ( paramètres )  {  // code qui saisit les données dans les paramètres  }  // ...  }
Mise en œuvre [ modifier ]] 
fonction  Consolemo ()  {  était  Console  =  nul ;  était  préparer  =  fonction ()  {  Console  =  nouveau  Consoleclass ();  Console . préparer ();  }  était  sans préchauffer  =  fonction ()  {  Console . sans préchauffer ();  }  était  courir  =  fonction ()  {  Console . imprimé ( "Bonjour le monde" ));  Console . imprimer ();  }  était  principal  =  fonction ()  {  ce . préparer ();  ce . courir ();  ce . sans préchauffer ();  }  }

Langages de programmation procédurale [ modifier ]]

Ce modèle peut être considéré comme une extension procédurale des langues orientées objet.

Bien que les paradigmes de programmation procéduraux et modulaires soient souvent utilisés ensemble, il existe des cas où un langage de programmation procédural peut ne pas prendre en charge les modules, nécessitant donc une implémentation de modèle de conception.

PHP (procédural) [ modifier ]]

Cet exemple s’applique au PHP procédural avant les espaces de noms (introduits dans la version 5.3.0). Il est recommandé que chaque membre d’un module reçoive un préfixe lié au nom de fichier ou au nom du module afin d’éviter les collisions d’identifiant.

Définition [ modifier ]] 
 // nom de fichier: console.php  fonction  console_prepare ()  {  // code qui prépare une "console"  }  fonction  console_unprepare ()  {  // Code qui décourage une "console"  }  // ...  fonction  console_printnewline ()  {  // code qui publie une nouvelle ligne  }  fonction  console_printstring ( /* Chaîne */  Valeur )  {  // code qui imprime les paramètres  }  fonction  console_printInteger ( / * Entier * /  Valeur )  {  // code qui imprime les paramètres  }  fonction  console_printboolean ( / * Booléen * /  Valeur )  {  // code qui imprime les paramètres  }  fonction  console_scannewline ()  {  // code qui recherche une nouvelle ligne  }  fonction  console_scanstring ( /* Chaîne */  Valeur )  {  // code qui stocke les données dans les paramètres  }  fonction  console_scanInteger ( / * Entier * /  Valeur )  {  // code qui stocke les données dans les paramètres  }  fonction  console_scanboolean ( / * Booléen * /  Valeur )  {  // code qui stocke les données dans les paramètres  }
Mise en œuvre [ modifier ]] 
// nom de fichier: consolemo.php  Demandez une fois ( "console.php" ));  fonction  ConsoleDemo_Prepare ()  {  console_prepare ();  }  fonction  ConsoleDemo_Unprepare ()  {  console_unprepare ();  }  fonction  ConsoleDemo_Execute ()  {  console_printstring ( "Bonjour le monde" ));  console_printnewline ();  console_scannewline ();  }  fonction  ConsoleDemo_Main ()  {  ConsoleDemo_Prepare ();  ConsoleDemo_Execute ();  ConsoleDemo_Unprepare ();  }

C [ modifier ]]

Notez que cet exemple s’applique à la procédure C sans espaces de noms. Il est recommandé que chaque membre d’un module reçoive un préfixe lié au nom de fichier ou au nom du module afin d’éviter les collisions d’identifiant.

[ modifier ]] 
 // Nom de fichier: "Consoles.h"   #inclure    #inclure    #inclure      annuler  consoles_prepare ();    annuler  consoles_unprepare ();   // ...     annuler  Consoles_printNewline ();     annuler  Consoles_printString ( carboniser *  Valeur ));    annuler  Consoles_printInteger ( int  Valeur ));    annuler  consoles_printboolean ( bool  Valeur ));     annuler  consoles_scannewline ();      annuler  Consoles_scanstring ( carboniser *  Valeur ));    annuler  Consoles_scanInteger ( int *  Valeur ));    annuler  consoles_scanboolean ( bool *  Valeur ));
Définition du module du corps [ modifier ]] 
 // nom de fichier: "Consoles.c"   #inclure    #inclure    #inclure    #inclure      annuler  consoles_prepare ()  {   // code qui prépare la console   }     annuler  consoles_unprepare ()  {      // code that unprepares console   }

  // ...
  
  void consoles_printNewLine() {
    printf("n");
  }
  
  void consoles_printString(char* Value) {
    printf("%s", Value);
  }
  
  void consoles_printInteger(int Value) {
    printf("%d", &Value);
  }
  
  void consoles_printBoolean(bool Value) {
    printf((Value) ? ("true") : ("false"));
  }
  
  void consoles_scanNewLine() {
    getch();
  }
  
  void consoles_scanString(char* Value) {
    scanf("%s", Value);
  }
  
  void consoles_scanInteger(int* Value) {
    scanf("%d", Value);
  }
  
  void consoles_scanBoolean(bool* Value) {
    char temp[512];
    scanf("%s", temp);
 
    *Value = (strcmp(Temp, "true") == 0);
  }
Mise en œuvre [ modifier ]] 
 // Nom de fichier: "ConsoleDemo.c"   #inclure    #inclure    #inclure    #inclure    annuler  ConsoleDemo_Prepare ()   {   consoles_prepare ();    }
   
  void consoledemo_unprepare()
  {
    consoles_unprepare();
  }
   
  int consoledemo_execute()
  {
    consoles_printString("Hello World");
    consoles_printNewLine();
    consoles_scanNewLine();
   
    return 0;
  }
   
  int main()
  {
    ErrorCode Result = 0;
  
    consoledemo_prepare();
    ErrorCode = consoledemo_execute();
    consoledemo_unprepare();
 
    return ErrorCode;
  }

Pascal procédural [ modifier ]]

Notez que cet exemple s’applique à la Pascal procédurale non modulaire. De nombreux dialectes Pascal ont une prise en charge de l’espace de noms, appelé “unité (s)”. Certains dialectes prennent également en charge l’initialisation et la finalisation.

Si les espaces de noms ne sont pas pris en charge, il est recommandé de donner à tous les noms des membres un préfixe lié au nom de fichier ou au nom du module afin d’éviter les collisions d’identifiant.

Définition [ modifier ]] 
 unité  consoles ;  (* filename: "consoles.pas" *)  les usages  CRT ;  procédure  préparer () ;  commencer  (* Code qui prépare la console *)  fin ;  procédure  sans préchauffer () ;  commencer  (* Code qui détruit la console *)  fin ;  // ...  procédure  imprimer () ;  commencer  Écrivain () ;  fin ;  procédure  imprimé ( Valeur :  chaîne ) ;  commencer  Écrire ( Valeur ) ;  fin ;  procédure  printInteger ( Valeur :  entier ) ;  commencer  Écrire ( Valeur ) ;  fin ;  procédure  printboolean ( Valeur :  booléen ) ;  commencer  si  ( Valeur )  alors  commencer  Écrire ( 'vrai' ) ;  fin  autre  commencer  Écrire ( 'FAUX' ) ;  fin ;  fin ;  procédure  scannewline () ;  commencer  Seekeoln () ;  fin ;  procédure  scandrage ( Valeur :  chaîne ) ;  commencer  Lecture ( Valeur ) ;  fin ;  procédure  scannentier ( Valeur :  Entier ) ;  commencer  Lecture ( Valeur ) ;  fin ;  procédure  scanboolean ( Valeur :  Booléen ) ;  était  temp :  chaîne ;  commencer  Lecture ( temp ) ;  si  ( Temp  =  'vrai' )  alors  commencer  Valeur  : =  vrai ;  fin  autre  commencer  Valeur  : =  FAUX ;  fin ;  fin ;
Mise en œuvre [ modifier ]] 
 programme  Consolemo ;  // filename: "consoles.pas"  les usages  consoles ;  procédure  préparer () ;  commencer  consoles . préparer () ;  fin ;  procédure  sans préchauffer () ;  commencer  consoles . sans préchauffer () ;  fin ;  fonction  exécuter () :  Entier ;  commencer  consoles . imprimé ( 'Bonjour le monde' ) ;  consoles . imprimer () ;  consoles . scannewline () ;  exécuter  : =  0 ;  fin ;  commencer  préparer () ;  exécuter () ;  sans préchauffer () ;  fin .

Comparaisons avec d’autres concepts [ modifier ]]

Espaces de noms [ modifier ]]

Les deux espaces de noms et modules Permettre de regrouper plusieurs entités connexes par un seul identifiant et, dans certaines situations, utilisé de manière interchangeable. Ces entités peuvent être accessibles à l’échelle mondiale. Le but principal des deux concepts est le même.

Dans certains scénarios, un espace de noms nécessite que les éléments globaux qui le composent sont initialisés et finalisés par une fonction ou un appel de méthode.

Dans de nombreux langages de programmation, espaces de noms ne sont pas directement destinés à prendre en charge un processus d’initialisation ni un processus de finalisation et ne sont donc pas équivalents aux modules. Cette limitation peut être élaborée de deux manières. Dans espaces de noms qui prennent en charge les fonctions globales, une fonction d’initialisation et une fonction de finalisation sont codées directement, et appelées directement dans le code du programme principal.

Classes et espaces de noms [ modifier ]]

Des classes sont utilisés parfois utilisés comme ou avec espaces de noms . Dans les langages de programmation qui ne prennent pas en charge les espaces de noms (par exemple, JavaScript) mais qui prennent en charge les classes et les objets, les classes sont souvent utilisées pour remplacer les espaces de noms. Ces classes ne sont généralement pas instanciées et se composent exclusivement de membres statiques.

Classes et espaces de noms singleton [ modifier ]]

Dans les langages de programmation orientés objet où les espaces de noms sont incomplètement pris en charge, le modèle singleton peut être utilisé à la place des membres statiques au sein d’une classe non instanable.

Relation avec d’autres modèles de conception [ modifier ]]

Le modèle de module peut être implémenté en utilisant une spécialisation du modèle Singleton. Cependant, d’autres modèles de conception peuvent être appliqués et combinés, dans la même classe.

Ce modèle peut être utilisé comme un décorateur , un poids mouche , ou un adaptateur .

Module comme modèle de conception [ modifier ]]

Le motif du module peut être considéré comme un motif de création et un motif structurel. Il gère la création et l’organisation d’autres éléments et les groupt comme le fait le modèle structurel.

Un objet qui applique ce modèle peut fournir l’équivalent d’un espace de noms , fournissant le processus d’initialisation et de finalisation d’une classe statique ou d’une classe avec des membres statiques avec une syntaxe et une sémantique plus propres et plus concises.

Il prend en charge des cas spécifiques où une classe ou un objet peut être considéré comme des données procédurales structurées. Et, vice versa, migrer des données de procédure structurées et considérées comme orientées objet.

Voir également [ modifier ]]

after-content-x4