« Langage C Sharp/Annexe/Glossaire » : différence entre les versions

Contenu supprimé Contenu ajouté
m Robot : Remplacement de texte automatisé (- n'est pas + n’est pas , - Aujourd'hui + Aujourd’hui , - d'euros + d’euros , - d'agir + d’agir , - l'apparence + l’apparence )
m Robot : Remplacement de texte automatisé (-\n(==={0,3})(?: *)([^\n=]+)(?: *)\1(?: *)\n +\n\1 \2 \1\n)
Ligne 11 :
Les sources de ce glossaire sont le [[wikt:Catégorie:Lexique en français de l’informatique | Lexique en français de l’informatique de Wiktionnaire]] et Wikipédia.
 
== A ==
=== Un Assembly ===
Un Assembly est une unité de déploiement indivisible. Il est produit par le compilateur CSC de la plateforme .NET et elle peut servir de bibliothèque ou d’exécutable.
Ligne 29 :
}}
 
=== Les attributs ===
Les attributs ou propriétés de classes sont habituellement composés d'un identificateur (ou nom ou clé) et d'une valeur.
{{Glossaire source
Ligne 36 :
}}
 
== B ==
=== Le Boot ( Amorce; Amorçage) ===
Le boot, ou l’amorce, ou encore l’amorçage, est la procédure de démarrage d’un ordinateur, qui comporte notamment le chargement du programme initial.
Ligne 44 :
}}
 
=== Le Bios ===
Le BIOS (Basic Input Output System, en français : « système élémentaire d'entrée/sortie ») est un ensemble de fonctions, contenu dans la mémoire morte (ROM) de la carte mère d'un ordinateur, lui permettant d'effectuer des opérations élémentaires lors de sa mise sous tension, par exemple le choix du périphérique pour démarrer le système d’exploitation (CD, USB, disque dur, etc).
{{ Glossaire source
Ligne 51 :
}}
 
== C ==
=== Le code source ===
Le code source est la forme sous laquelle un programme est créé par un programmeur : Un ensemble de textes décrivant formellement, étape par étape, les opérations à effectuer; rédigés conformément aux règles d'un langage de programmation.
Ligne 59 :
}}
 
=== Un chemin d'accès ===
Un chemin d'accès d'un fichier ou d'un répertoire (path en anglais) est une chaîne de caractères décrivant la position de ce fichier ou répertoire dans le système de fichiers. Il permet aux programmes de retrouver ce fichier ou ce répertoire.
{{Glossaire source
Ligne 66 :
}}
 
=== Un chemin d'accès absolu ===
Un chemin d’accès absolu ou chemin absolu (absolute path) est un chemin d’accès d’un fichier ou répertoire qui est définit du point de vue de la racine (root en anglais) du système de fichier.
Les chemins absolu sous Windows commence par la lettre du disque suivie de «:\ » et ensuite chaque répertoire sont séparé par « \ » pour finir par le nom du fichier ou du répertoire.
Ligne 73 :
|wikipédia = chemin d'accès absolu
}}
=== Un chemin d'accès relatif ===
Un chemin d’accès relatif ou chemin relatif (relative path) est une référence à un fichier ou répertoire qui est définit du point de vue du répertoire courant.
Le chemin relatif peut :
Ligne 84 :
|wikipédia = chemin d'accès relatif
}}
=== Un compilateur ===
Un compilateur est un programme informatique qui traduit un code source écrit dans un langage de programmation (par exemple C#) en un autre langage, habituellement un langage d'assemblage ou un langage machine (par exemple {{abréviation|MSIL|MicroSoft Intermediate Language|en}}, MicroSoft Intermediate Language). Le ou les fichiers obtenus sont nommés des exécutables ou des bibliothèques (d’instructions) utilisables par d’autres programmes.
{{Glossaire source
Ligne 90 :
|wikipédia = compilateur (informatique)
}}
=== Une classe ===
Une classe déclare des propriétés communes à un ensemble d'objets. La classe déclare des attributs représentant l'état des objets et des méthodes représentant leur comportement.
{{Glossaire source
Ligne 97 :
}}
 
=== Les classes statiques et les membres statiques ===
Les classes statiques et les membres statiques sont utilisés pour créer des données et des fonctions auxquelles il est possible d'accéder sans créer d'instance de la classe. Des membres de classes statiques peuvent être utilisés pour séparer les données et le comportement, qui est indépendant de toute identité de l’objet : les données et les fonctions ne changent pas, quoi qu’il arrive à l'objet. Les classes statiques peuvent être utilisées lorsqu’il n'y a pas de données ou de comportement dans la classe qui dépende de l'identité de l'objet.
{{Glossaire source
Ligne 103 :
|wikipédia = classe statique (informatique)
}}
=== Un champ ===
Dans C#, un champ est une variable de tout type déclaré directement dans une classe ou un struct.
{{Glossaire source
Ligne 109 :
|wikipédia = champ (Dans C#)
}}
=== Un constructeur ===
Un constructeur est une fonction particulière qui permet d'instancier, c’est-à-dire créer un objet en mémoire vive. Le constructeur permet d'allouer la mémoire nécessaire à l’objet et d'initialiser ses attributs.
{{Glossaire source
Ligne 115 :
|wikipédia = constructeur (informatique)
}}
=== Un constructeur (dans C#) ===
Un constructeur est une fonction qui porte le même nom que la classe qu’il initialise.
{{Glossaire source
Ligne 122 :
}}
 
== D ==
=== Les droits sur un fichier ===
Les droits sur un fichier (et donc aussi répertoire) permettent de restreindre les accès à un fichier, suivant un certain nombre de paramètres. C'est une des bases de la sécurité informatique.
Ligne 133 :
}}
 
== E ==
=== Une extension de nom de fichier ===
Une extension de nom de fichier (ou simplement extension de fichier, voire extension) est un suffixe ajouté au nom d'un fichier pour identifier son format. Ainsi, on dira qu'un fichier nommé doc.txt à l'extension txt ou .txt.
Ligne 140 :
|wikipédia = extension de fichier
}}
=== Les espaces de noms ===
Les espaces de noms permettent d’organiser les programmes et les bibliothèques C# de façon hiérarchisée. Ils contiennent des types et d’autres espaces de noms.
{{Glossaire source
Ligne 147 :
}}
 
== F ==
=== Un fichier ===
Un fichier (file en anglais) est un lot d'informations portant un nom et conservé dans une mémoire.
Ligne 155 :
|wikipédia = fichier (informatique)
}}
=== Un fichier Batch ===
Un fichier batch (Unix) ou un script (MS-DOS) ou fichier de commandes permet un traitement par lots (batch processing en anglais) qui est un enchaînement automatique de commandes sur un ordinateur sans intervention d'un opérateur.
{{Glossaire source
Ligne 161 :
|wikipédia = fichier batch
}}
=== Une fonction ===
Une fonction est une portion de code représentant un sous-programme, qui effectue une tâche ou un calcul relativement indépendant du reste du programme. Une fonction à une entrée (les arguments, ou paramètres qu'on lui donne), exécute un travail sur ces arguments, et, généralement, retourne une valeur (la sortie).
{{Glossaire source
Ligne 168 :
}}
 
== G ==
== H ==
=== Héritage ===
Héritage , Principe selon lequel une classe "fille" a les mêmes caractéristiques que sa classe "mère". On dit que la classe "fille" hérite ou dérive de sa classe "mère". Il s'agit d'une relation :
* Transitive : si B hérite de A et si C hérite de B alors C hérite de A ;
Ligne 181 :
}}
 
== I ==
=== Une interface ===
Une interface définit la frontière de communication entre deux entités (logiciel, matériel informatique, ou utilisateur).
Ligne 189 :
}}
 
=== Une interface en ligne de commande ===
Une interface en ligne de commande (ou prompt) est une interface homme-machine dans laquelle la communication entre l'utilisateur et l'ordinateur s'effectue en mode texte.
{{Glossaire source
Ligne 195 :
|wikipédia = interface en ligne de commande
}}
=== L'instanciation ===
L'instanciation est l'action d'instancier, de créer un objet à partir d'un modèle qui peut être une classe. Elle est réalisée par la composition de deux opérations : l'allocation et l'initialisation. L'allocation consiste à réserver un espace mémoire au nouvel objet. L'initialisation consiste à fixer l'état du nouvel objet.
{{Glossaire source
Ligne 201 :
|wikipédia = instanciation
}}
=== Instance ===
On appelle instance d'une classe, un objet instancié en mémoire avec un comportement et un état, tous deux définis par la classe. Une classe peut avoir plusieurs instances à un instant donné du fonctionnement d’un programme.
{{Glossaire source
Ligne 207 :
|wikipédia = instance d'une classe
}}
=== L'interface d'une classe ===
L’interface d’une classe est l’ensemble des méthodes publiques de la classe. De l'extérieur de la classe, on ne modifie l'instance de cette classe que par l'intermédiaire de son interface c’est-à-dire de ses méthodes publiques.
{{Glossaire source
Ligne 214 :
}}
 
== M ==
=== Le multiboot ===
Le multiboot est un terme informatique qui désigne la possibilité d'installer sur un même ordinateur plusieurs systèmes d’exploitation et de choisir l'un d'eux lors du démarrage de l'ordinateur.
Ligne 221 :
|wikipedia = multiboot
}}
=== Un membre ou une méthode ===
Un membre ou une méthode définit le plus souvent une fonction ou une procédure contenu dans une classe.
{{Glossaire source
Ligne 227 :
|wikipedia = membre (informatique)
}}
=== Le modificateur static ===
Le modificateur static déclare qu'un membre de classe appartient à une classe plutôt qu'aux instances de celle-ci.
{{Glossaire source
Ligne 233 :
|wikipedia = modificateur static (informatique)
}}
=== Un moteur d'exécution ===
Un moteur d'exécution, bibliothèque d'exécution ou runtime (abréviation de runtime system ou runtime library, runtime signifiant, en anglais, « au moment de l'exécution ») est un programme ou une bibliothèque qui permet l'exécution d'un autre programme. À cet effet, un moteur d'exécution comprend tout le code et toutes les données du langage dont un programme pourrait avoir besoin pendant son exécution. Chaque implémentation d'un langage ou d'une famille de langages fournit donc en général un moteur d'exécution pour les programmes qu'elle va compiler et/ou interpréter.
{{Glossaire source
Ligne 239 :
|wikipedia = moteur d'exécution (informatique)
}}
=== Le membre est dit surchargé ===
Dans C#,le membre est dit surchargé quand deux ou plusieurs membres d'un type représentent le même type de membre (méthode, propriété, constructeur, etc.), qu’ils possèdent le même nom mais des listes de paramètres différentes.
{{Glossaire source
Ligne 246 :
}}
 
== N ==
 
== O ==
=== Un ordinateur ===
Un ordinateur est une machine électronique qui fonctionne par la lecture séquentielle d'un ensemble
Ligne 256 :
|wikipédia = ordinateur
}}
=== Un objet ===
Un objet est un conteneur symbolique, qui possède sa propre existence et incorpore des informations et des mécanismes en rapport avec une chose tangible du monde réel manipulée dans un programme. C'est le concept central de la programmation orientée objet (POO). Un objet est créé ou instancié à partir d'un modèle appelé classe, duquel il hérite les comportements et les caractéristiques. Les comportements et les caractéristiques sont typiquement basés sur celles propres aux choses qui ont inspiré l'objet: une personne, un dossier, un produit.
{{Glossaire source
Ligne 262 :
|wikipédia = objet (informatique)
}}
=== Une opérande ===
Un opérande est un terme mis en argument dans une opération.
{{Glossaire source
Ligne 268 :
|wikipédia = opérande (informatique)
}}
=== Un opérateur ===
Un opérateur est une fonction spéciale dont l'identificateur s'écrit avec des caractères non autorisés pour les identificateurs fonctions ordinaires.
{{Glossaire source
Ligne 275 :
}}
 
== P ==
=== Un programme ===
Un programme ou exécutable est une suite d'instructions destinées à être exécutées de manière automatique
Ligne 285 :
}}
 
=== Un programme console ===
Un programme console est un programme informatique conçu pour être utilisé via un mode texte entre l’utilisateur et l'ordinateur via l'interface en ligne de commande de certains systèmes d'exploitation.
{{Glossaire source
Ligne 291 :
|wikipédia = Programme console (informatique)
}}
=== Une procédure ===
Une procédure, aussi appelée routine ou sous-routine, est une fonction mais qui ne renvoi pas de résultat.
{{Glossaire source
Ligne 297 :
|wikipédia = procédure (informatique)
}}
=== Le polymorphisme ===
Le polymorphisme est le mécanisme par lesquels des classes dérivées peuvent étendre et spécialiser des classes de base.
{{Glossaire source
Ligne 304 :
}}
 
== R ==
=== Un répertoire ===
Un répertoire ou dossier (folder en anglais) est une liste de descriptions de fichiers. Du point de vue du système de fichiers, il est traité comme un fichier dont le contenu est la liste des fichiers référencés. Un répertoire a donc les mêmes types de propriétés qu'un fichier comme le nom, la taille, la date, les droits d'accès et les divers autres attributs.
Ligne 311 :
|wikipédia = répertoire (informatique)
}}
=== Répertoire courant ===
Répertoire courant est le répertoire dans lequel un programme se trouve à un instant donné durant la navigation dans le système de fichier.
{{Glossaire source
Ligne 318 :
}}
 
== S ==
=== Le système d'exploitation ===
Le système d'exploitation (en anglais operating system, abrégé {{abréviation|OS|Operating System|en}}) est l’ensemble de programmes central d'un appareil informatique qui sert d'interface entre le matériel et les logiciels applicatifs.
Ligne 325 :
|wikipédia = système d'exploitation
}}
=== Un système de fichiers ===
Un système de fichiers (file system ou filesystem en anglais) ou système de gestion de fichiers (SGF) est une façon de stocker les informations et de les organiser dans des fichiers sur ce que l’on appelle des mémoires secondaires (disque dur, CD-ROM, clé USB, SSD, etc.). Une telle gestion des fichiers permet de traiter, de conserver des quantités importantes de données ainsi que de les partager entre plusieurs programmes informatiques.
{{Glossaire source
Ligne 331 :
|wikipédia = système de fichiers
}}
=== La surcharge ===
La surcharge est une technique de programmation qui permet de donner le même rôle à un opérateur ou à une fonction avec de nouveaux types d’opérandes.
{{Glossaire source
Ligne 337 :
|wikipédia = Surcharge (informatique)
}}
=== La signature d'un membre ===
Dans C#,la signature d'un membre comprend son nom et sa liste de paramètres. Chaque signature de membre doit être unique dans le type. Les membres peuvent avoir le même nom pour autant que leurs listes de paramètres diffèrent.
{{Glossaire source
Ligne 344 :
}}
 
== T ==
=== Un type de donnée ===
Un type de donnée, ou simplement type, définit les valeurs que peut prendre une donnée, ainsi que les opérateurs qui peuvent lui être appliqués.
Ligne 351 :
|wikipédia = type de donnée (informatique)
}}
=== Un type Struct ===
Un type struct (structure) est un type valeur qui est utilisé en général pour encapsuler des petits groupes de variables.
{{Glossaire source
Ligne 357 :
|wikipédia = type Struct (informatique)
}}
=== Un type numérique signé ===
Un type numérique signé : On dit qu’un type d’une variable est signé, si la valeur de cette variable peut-être positif ou négatif.
{{Glossaire source
Ligne 363 :
|wikipédia = type numérique signé (informatique)
}}
=== Un type numérique non-signé ===
Un type numérique non-signé : On dit qu’un type d’une variable est non-signé, si la valeur de cette variable ne peut pas représenter un nombre négatif (nombre nul ou positif).
{{Glossaire source
Ligne 369 :
|wikipédia = type numérique non-signé (informatique)
}}
=== Un type classe ===
Dans C#,un type classe définit une structure de données qui contient des données membres (champs) et des fonctions membres (méthodes, propriétés, etc.). Les types classe prennent en charge l’héritage unique et le polymorphisme.
{{Glossaire source
Ligne 375 :
|wikipédia = type classe (C#)
}}
=== Un type interface ===
Dans C#,un type interface définit un contrat de fonctions publiques membres. Une classe ou un struct qui implémente une interface doit fournir des implémentations des fonctions membres de l’interface. Une interface peut hériter de plusieurs interfaces de base, et une classe ou un struct peut implémenter plusieurs interfaces.
{{Glossaire source
Ligne 381 :
|wikipédia = type interface (C#)
}}
=== Un type délégué ===
Dans C#,un type délégué représente des références à des méthodes avec une liste de paramètres et un type de retour particuliers. Les délégués permettent de traiter des méthodes comme des entités pouvant être assignées aux variables et passées en tant que paramètres.
{{Glossaire source
Ligne 387 :
|wikipédia = type délégué (C#)
}}
=== Un type enum ===
Dans C#,un type enum est un type distinct avec des constantes nommées. Chaque type enum a un type sous-jacent qui doit être l’un des huit types intégraux. L’ensemble des valeurs d’un type enum est identique à l’ensemble des valeurs du type sous-jacent.
{{Glossaire source
Ligne 394 :
}}
 
== V ==
=== Les variables de types valeur ===
Dans C#,les variables de types valeur contiennent directement leurs données.
Ligne 400 :
|:en:w = Value type
}}
=== Les variables de types référence ===
Dans C#,les variables de types référence stockent des références à leurs données, ces dernières étant appelées « objets ».
{{Glossaire source