'>

langage de programmation C Sharp

C # [note 1] (prononcé voir sharp) est un langage de programmation multi-paradigme englobant typage fort,,,,,, axée objet (class-based) fonctionnel déclaratif impératif de procédure générique, et les disciplines de programmation orientée composants. Il a été développé par Microsoft dans son initiative. NET et plus tard approuvé comme norme par l'ECMA (ECMA-334) et l'ISO (ISO / IEC 23270:2006). C # est l'un des langages de programmation conçus pour le Common Language Infrastructure.
C # est destiné à être un moderne, polyvalent, simple langage de programmation orienté objet. [6] Son équipe de développement est dirigé par Anders Hejlsberg. La version la plus récente est C # 5.0, qui a été publié le 15 Août 2012.
Les objectifs de conception
La norme ECMA répertorie ces objectifs de conception pour C #: [6]

    
Le langage C # est destiné à être un moderne, polyvalent, simple langage de programmation orienté objet.
    
La langue et leurs implémentations, devraient fournir un soutien des principes de génie logiciel telles que contrôle strict des types, des bornes de tableaux de contrôle, détection des tentatives d'utiliser des variables non initialisées, et la collecte des ordures automatique. robustesse du logiciel, la durabilité et la productivité du programmeur sont importants.
    
La langue est destiné à être utilisé dans le développement de composants logiciels adaptées à un déploiement dans des environnements distribués.
    
Source portabilité du code est très importante, tout comme la portabilité du programmeur, en particulier pour les programmeurs déjà familiers avec C et C + +.
    
Soutien à l'internationalisation est très importante.
    
C # est destiné à être adapté à l'écriture d'applications pour les systèmes hébergés et intégrés, allant de la très grande qui utilisent les systèmes d'exploitation sophistiqués, jusque dans les très petites ayant des fonctions dédiées.
    
Bien que les applications C # sont destinés à être rentable au regard des exigences de puissance mémoire et de traitement, la langue n'était pas destiné à rivaliser directement sur la performance et la taille avec C ou assembleur.
NomNote de musique C-sharp (à gauche)
Le nom de «C sharp" a été inspiré par une notation musicale où une forte indique que la note écrite doit être faite un demi-ton plus aigu. [7] Ceci est similaire au nom de la langue de C + +, où "+ +" indique qu'une variable doit être incrémenté de 1.
En raison de limitations techniques de l'affichage (polices standard, navigateurs, etc) et le fait que le symbole dièse (U +266 F ♯ signe dièse musique (HTML: ♯)) n'est pas présent sur le clavier standard, le signe dièse (U + 0023 # dièse (HTML: #)) a été choisi pour représenter le symbole dièse dans le nom écrit du langage de programmation [8] Cette convention est reflétée dans la norme ECMA-334 C # Language Specification [6] Cependant, quand il est.. pratique de le faire (par exemple, dans la publicité ou dans la boîte art [9]), Microsoft utilise le symbole musical prévu.
Le suffixe "forte" a été utilisé par un certain nombre d'autres. Langues NET qui sont des variantes de langues existantes, y compris J # (un langage. NET également conçu par Microsoft qui est dérivé de Java 1.1), A # (à partir de Ada), et le langage de programmation fonctionnel F #. [10] La mise en œuvre initiale de Eiffel pour. NET a été appelé # Eiffel, [11] un nom à la retraite depuis le langage plein Eiffel est maintenant supporté. Le suffixe a également été utilisé pour les bibliothèques, comme Gtk # (un fichier. NET wrapper pour GTK + et d'autres bibliothèques GNOME), Cocoa # (un wrapper pour le cacao).Histoire
Lors de l'élaboration du. NET Framework, les bibliothèques de classes ont été écrits en utilisant un système de compilation de code managé appelé Simple C Géré (SMC). [12] [13] [14] En Janvier 1999 Anders Hejlsberg formé une équipe pour construire un nouvelle langue à l'époque appelée Cool, qui se tenait pour «C-comme Object Oriented Language". [15] Microsoft avait examiné en gardant le nom de "Cool" comme le nom définitif de la langue, mais a choisi de ne pas le faire pour des raisons de marques. Au moment où le projet. NET a été annoncée publiquement au 2000 Professional Developers Conference Juillet, la langue avait été rebaptisé C #, et les bibliothèques de classes et ASP.NET exécution avait été porté à C #.
Concepteur principal de C # et architecte principal chez Microsoft est Anders Hejlsberg, qui a déjà été impliqué dans la conception de Turbo Pascal, Embarcadero Delphi (anciennement CodeGear Delphi, Inprise Delphi et Borland Delphi) et Visual J + +. Dans des interviews et des documents techniques, il a déclaré que les défauts [citation nécessaire] dans la plupart des langages de programmation principaux (par exemple, C + +, Java, Delphi, et Smalltalk) ont conduit les fondamentaux du Common Language Runtime (CLR), qui, à son tour, conduit la conception du langage C # lui-même.
James Gosling, qui a créé le langage de programmation Java en 1994, et Bill Joy, cofondateur de Sun Microsystems, le créateur de Java, appelé C # une "imitation" de Java, Gosling a également affirmé que «[C # est] sorte de Java avec la fiabilité, la productivité et la sécurité supprimés. »[3] [16] Klaus Kreft et Angelika Langer (auteurs d'un livre C + + flux) a déclaré dans un billet de blog que" Java et C # sont des langages de programmation presque identiques. répétition ennuyeuse qui manque d'innovation, »[17]« Presque personne ne prétendra que Java ou C # sont des langages de programmation révolutionnaires qui ont changé notre façon d'écrire des programmes »et« C # emprunté beaucoup de Java -. et vice versa Maintenant que C # prend en charge boxing et unboxing, nous allons avoir une fonction très similaire à Java. »[18] Anders Hejlsberg a fait valoir que C #" n'est pas un clone de Java »et est« beaucoup plus proche de C + + "dans sa conception. [19]
Depuis la sortie de C # 2.0 en Novembre 2005, le C # et Java langues ont évolué sur des trajectoires de plus en plus divergents, devenant un peu moins similaire. Un des premiers grands départs est venu avec l'ajout de médicaments génériques aux deux langues, avec des réalisations très différentes. C # fait usage de la réification de fournir "première classe" objets génériques qui peuvent être utilisés comme n'importe quelle autre classe, avec la génération de code exécuté au moment de classe vide. [20] En revanche, les génériques de Java sont essentiellement une fonction de la syntaxe du langage, et ils n'affectent pas le byte code généré, car le compilateur effectue l'effacement de type sur des informations de type générique après avoir vérifié son exactitude. [21]
En outre, C # a ajouté plusieurs fonctionnalités majeures pour accueillir la programmation fonctionnelle de style, culminant dans les extensions LINQ libérés avec C # 3.0 et sa structure de support des expressions lambda, les méthodes de vulgarisation, et des types anonymes. [22] Ces fonctionnalités permettent aux programmeurs C # à l'utilisation fonctionnelle techniques de programmation, comme la fermeture, quand il est avantageux de leur application. Les extensions LINQ et les importations fonctionnels aident les développeurs à réduire la quantité de code «passe-partout» qui est inclus dans les tâches courantes telles que l'interrogation d'une base de données, l'analyse d'un fichier XML, ou en cherchant dans une structure de données, en déplaçant l'accent sur la logique réelle du programme d'aide améliorer la lisibilité et de maintenabilité. [23]
C # utilisé pour avoir une mascotte appelée Andy (nommé d'après Anders Hejlsberg). Il a pris sa retraite le 29 janvier 2004. [24]
C # a été soumis à l'examen du sous-comité ISO JTC 1/SC 22 [25] selon la norme ISO / IEC 23270:2003 [26], qui est maintenant retirée. Il a ensuite été approuvé en vertu de la norme ISO / IEC 23270:2006. [27]Versions
Dans le cadre de son développement, le langage C # a connu plusieurs versions:Specification Language Version Date. NET Framework Visual StudioECMA ISO / IEC MicrosoftC # 1.0 Décembre 2002 Avril 2003 Janvier 2002 Janvier 2002. NET Framework 1.0 Visual Studio. NET 2002C # 1.2 Octobre 2003 Avril 2003. NET Framework 1.1 Visual Studio. NET 2003C # 2.0 Juin 2006 Septembre 2006 Septembre 2005 [A] Novembre 2005. NET Framework 2.0 Visual Studio 2005C # 3.0 Aucun [B] Août 2007 Novembre 2007
. NET Framework 2.0 (Sauf LINQ / Extensions requête) [28]. NET Framework 3.0 (Sauf LINQ / Extensions requête) [28]. NET Framework 3.5Visual Studio 2008Visual Studio 2010C # 4.0 Avril 2010 Avril 2010. NET Framework 4 Visual Studio 2010C # 5.0 Juin 2013 Août 2012. NET Framework 4.5 Visual Studio 2012Un document # 2.0 des spécifications de Microsoft C ne contient que les nouvelles fonctionnalités 2.0. Pour les fonctions plus âgés utilisent la spécification 1.2 ci-dessus.B Pas ECMA ou spécifications ISO / IEC existent pour C # 3.0, 4.0 ou 5.0.Résumé des versions C # 2.0 C # 3.0 C # 4.0 C # 5.0 [29] FutureTraitsajoutée

    
Generics
    
Types partiels
    
Les méthodes anonymes
    
Iterators
    
Les types Nullable
    
Setters privés (propriétés)
    
conversions de groupe de la méthode (délégués)



    
Variables locales implicitement typées
    
Objets et de collection
    
Propriétés implémentées automatiquement
    
Les types anonymes
    
Les méthodes d'extension
    
Les expressions de requête
    
Les expressions lambda
    
Les arborescences d'expression
    
Méthodes partielles



    
La liaison dynamique
    
Les arguments nommés et facultatifs
    
Co-générique et contravariance
    
Types d'interopérabilité incorporés ("NOPIA")



    
Méthodes asynchrones
    
attributs d'information de l'appelant



    
Compiler-as-a-service ("Roslyn")
    
aperçu technologique communautaire Septembre 2012
SyntaxeArticle détaillé: C syntaxe ForteVoir aussi: syntaxe (langage de programmation)
C # a la syntaxe suivante:

    
Virgules sont utilisés pour désigner la fin d'une instruction.
    
Les accolades sont utilisées pour les états de groupe. Les déclarations sont généralement regroupées dans des méthodes (fonctions), les méthodes dans des classes et des classes dans les espaces de noms.
    
Les variables sont attribués en utilisant un signe égal, mais comparés à l'aide de deux signes consécutifs égaux.
    
Les crochets sont utilisés avec des tableaux, à la fois pour les déclarer et d'obtenir une valeur à un indice donné dans l'un d'eux.
Les signes distinctifs

    
Note: La description suivante est basée sur la norme de la langue et d'autres documents énumérés dans la section «Liens externes».
De par sa conception, C # est le langage de programmation qui reflète plus directement le Common Language Infrastructure sous-jacent (CLI). [30] La plupart de ses types intrinsèques correspondent à des types de valeur mis en œuvre par le cadre CLI. Toutefois, la spécification du langage n'indique pas les exigences de génération de code du compilateur: c'est à dire qu'il ne dit pas qu'un compilateur C # doit cibler un Common Language Runtime, ou de générer Common Intermediate Language (CIL), ou de générer n'importe quel autre format spécifique. Théoriquement, un compilateur C # pourrait générer du code machine comme les compilateurs traditionnels de C + + ou Fortran. Quelques caractéristiques notables de C # qui la distinguent de C et C + + (et Java, où noté) sont:

    
C # prend en charge les déclarations de variables implicites fortement typés avec le mot-clé var, et les tableaux implicitement typés avec le mot-clé new [] suivie d'un initialiseur de collection.
    
Meta Programming via des attributs C # est une partie de la langue. Beaucoup de ces attributs dupliquer les fonctionnalités de GCC et VisualC + s '+ directives du préprocesseur dépendant de la plateforme.
    
Comme en C + +, et contrairement à Java, C # programmeurs doivent utiliser le mot-clé virtuelle pour permettre des méthodes pour être remplacée par les sous-classes.
    
Les méthodes d'extension en C # permet aux programmeurs d'utiliser des méthodes statiques comme si elles étaient des méthodes de la table des méthodes d'une classe, ce qui permet aux programmeurs d'ajouter des méthodes à un objet qu'ils se sentent devrait exister sur cet objet et ses dérivés.
    
La dynamique de type permet de méthode de reliure run-time, permettant JavaScript comme des appels de méthode et de la composition de l'objet de l'exécution.
    
C # a fortement typé et le soutien de pointeur de fonction verbose via le mot-clé délégué.
    
Comme le framework Qt de pseudo-C + + signal et fente, C # a une sémantique entourant spécifiquement publish-subscribe événements de style, bien que C # utilise des délégués pour le faire.
    
C # offre Java-like appels de méthodes synchronisées, via l'attribut [MethodImpl (MethodImplOptions.Synchronized)], et bénéficie du soutien des verrous mutuellement exclusifs via le verrouillage de mot-clé.
    
Les langages C # ne permet pas de variables ou des fonctions globales. Toutes les méthodes et les membres doivent être déclarés dans les classes. Les membres statiques de classes publiques peuvent remplacer les variables et les fonctions globales.
    
Les variables locales ne peuvent pas observer les variables du bloc englobant, contrairement à C et C + +.
    
AC # espace de noms fournit le même niveau d'isolation de code comme un package Java ou C + + namespace, avec des règles et des caractéristiques très similaires à celles d'un paquet.
    
C # prend en charge un type de données Boolean strict, bool. Les déclarations qui prennent conditions, comme tout et si besoin une expression d'un type qui implémente le véritable opérateur, telles que le type booléen. Alors que C + + a aussi un type booléen, il peut être librement convertis vers et à partir des nombres entiers, et des expressions telles que si (a) exiger seulement que a est convertible en bool, ce qui permet un étre un entier ou un pointeur. C # n'autorise pas cette approche "integer sens vrai ou faux", au motif que forcer les programmeurs d'utiliser des expressions qui renvoient exactement bool peuvent empêcher certains types d'erreurs de programmation courantes en C ou C + + comme si (a = b) (utilisation d'affectation = au lieu de l'égalité ==).
    
En C #, pointeurs d'adresses de mémoire ne peuvent être utilisés que dans des blocs marqués comme dangereux, et les programmes avec code dangereux doivent autorisations appropriées pour exécuter. La plupart des accès aux objets se fait à travers des références d'objet SAFE, qui toujours l'un des points à un objet "live" ou avoir la valeur null bien défini, il est impossible d'obtenir une référence à un objet «mort» (celui qui a été garbage collector) , ou à un bloc aléatoire de la mémoire. Un pointeur dangereux peut pointer vers une instance de type valeur, un tableau, une chaîne ou un bloc de mémoire allouée sur une pile. Le code qui n'est pas marqué comme dangereux peut encore stocker et manipuler des pointeurs à travers le type System.IntPtr, mais il ne peut pas déréférencer eux.
    
Géré mémoire ne peut pas être explicitement libéré, mais plutôt, il est automatiquement ordures collectées. Collecte des ordures ménagères aborde le problème des fuites de mémoire en libérant le programmeur de la responsabilité de libérer la mémoire qui n'est plus nécessaire.
    
En plus de la construction TRY ... CATCH pour gérer les exceptions, C # a un try ... finally construire pour garantir l'exécution du code dans le bloc finally, si une exception se produise ou non.
    
L'héritage multiple n'est pas supporté, même si une classe peut implémenter un nombre quelconque d'interfaces. Il s'agissait d'une décision de conception par l'architecte principal du langage pour éviter les complications et simplifier les exigences architecturales à travers CLI. Lors de l'implémentation des interfaces multiples qui contiennent une méthode avec la même signature, C # permet au programmeur de mettre en œuvre chaque méthode selon l'interface que la méthode est appelée par, ou, comme Java, permet au programmeur d'implémenter la méthode une fois et avoir que soit le invocation unique sur un appel via une des interfaces de la classe.
    
C #, contrairement à Java, en charge la surcharge d'opérateur. Seuls les opérateurs les plus fréquemment surchargés en C + + peut être surchargé en C #.
    
C # est plus sûr que le type C + +. Les seules conversions implicites par défaut sont ceux qui sont considérés comme sûrs, tels que l'élargissement des nombres entiers. Ceci est renforcé lors de la compilation, au cours de JIT, et, dans certains cas, à l'exécution. Pas de conversions implicites surviennent entre booléens et entiers, ni entre les membres de l'énumération et les nombres entiers (sauf littérale 0, ce qui peut être implicitement converti en un type énuméré). N'importe quel utilisateur défini conversion doit être explicitement marquée comme explicite ou implicite, contrairement au C + + constructeurs de copie et les opérateurs de conversion, qui sont à la fois implicite par défaut.
    
C # a le soutien explicite de la covariance et contravariance dans les types génériques, contrairement au C + + qui a un certain degré de soutien contravariance simplement grâce à la sémantique des types de retour sur les méthodes virtuelles.
    
En C #, comme dans d'autres langages basés sur les classes comme Java et Scala, classe / interface de l'héritage et de la classe / interface de sous-typage suis entièrement d'accord, en raison de la nominality du système de type de ces langues. [31]
    
membres de l'énumération sont placés dans leur propre champ d'application.
    
C # fournit des propriétés que le sucre syntaxique pour un motif commun dans lequel une paire de méthodes accesseur (getter) et mutator (setter) encapsulent des opérations sur un seul attribut d'une classe. Pas redondants signatures de méthode pour les implémentations de getter / setter besoin d'être écrites, et la propriété peuvent être accessibles en utilisant la syntaxe d'attribut plutôt que méthode plus prolixes appels.
    
Les exceptions contrôlées ne sont pas présents en C # (contrairement à Java). Cela a été une décision consciente basée sur les questions d'évolutivité et de versionability. [32]
    
Bien que principalement un langage impératif, puisque C # 3.0, il prend en charge les techniques de programmation fonctionnelle à travers des objets de la fonction de première classe et les expressions lambda.
Système de type commun
C # a un système de type unifié. Ce système de type unifié est appelé système de type commun (CTS). [33]
Un système de type unifié implique que tous les types, y compris des primitives telles que les entiers sont sous-classes de la classe System.Object. Par exemple, chaque type hérite d'une méthode ToString ().Catégories de types de données
CTS sépare les types de données en deux catégories: [33]

    
Les types de valeur
    
Les types de référence
Les instances de types valeurs n'ont pas d'identité référentielle ni sémantique de comparaison référentielles - l'égalité et l'inégalité des comparaisons des types de valeur comparent les valeurs réelles des données au sein des instances, à moins que les opérateurs correspondants sont surchargés. Les types de valeur sont dérivées de System.ValueType, ont toujours une valeur par défaut, et peut toujours être créées et copiées. Certaines autres restrictions sur les types de valeurs sont qu'ils ne peuvent pas provenir de l'autre (mais peuvent implémenter des interfaces) et ne peuvent pas avoir un constructeur par défaut explicite (sans paramètre). Des exemples de types de valeurs sont tous les types primitifs, tels que int (un entier signé 32 bits), float (IEEE un nombre à virgule flottante 32 bits), char (une unité de code Unicode 16 bits), et System.DateTime ( identifie un point précis dans le temps avec une précision à la nanoseconde). D'autres exemples sont ENUM (énumérations) et structure (structures définies par l'utilisateur).
En revanche, les types de référence ont la notion d'identité référentielle - chaque instance d'un type de référence est fondamentalement distincte de tous les autres cas, même si les données contenues dans les deux cas est le même. Cela se reflète dans l'égalité par défaut et des comparaisons d'inégalité pour les types référence, qui teste de référentiel plutôt que l'égalité structurelle, à moins que les opérateurs correspondants sont surchargés (comme c'est le cas pour System.String). En général, il n'est pas toujours possible de créer une instance d'un type de référence, ni de copier une instance existante, ou effectuer une comparaison de la valeur sur deux instances existantes, bien que les types de référence spécifiques peuvent fournir ces services en exposant un constructeur public ou mettre en œuvre un interface correspondante (comme ICloneable ou IComparable). Des exemples de types de référence sont l'objet (la classe de base pour toutes les autres classes C #), System.String (une chaîne de caractères Unicode) et System.Array (une classe de base pour tous les tableaux # C).
Les deux catégories de types sont extensibles avec des types définis par l'utilisateur.Boxing et unboxing
La boxe est l'opération de conversion d'un objet de type valeur en une valeur d'un type de référence correspondant. [33] boxe en C # est implicite.
Unboxing est l'opération de conversion d'une valeur d'un type de référence (auparavant encadré) en une valeur d'un type de valeur [33]. Unboxing en C # requiert un type explicite. Un objet en boîte de type T ne peut être unboxing à un T (ou un nullable T) [34].
Exemple:
int foo = 42; / / Type de valeur.objet bar = foo / / foo est encadré au bar.int foo2 = (int) bar; / / boîte ouverte de nouveau à type de valeur.
Generics
Les génériques ont été ajoutées à la version 2.0 du langage C #. Les génériques utilisent les paramètres de type, qui permettent à des classes et méthodes de conception qui ne précisent pas le type utilisé jusqu'à ce que la classe ou la méthode est instancié. Le principal avantage est que l'on peut utiliser les paramètres de type générique pour créer des classes et des méthodes qui peuvent être utilisées sans encourir le coût de moulages d'exécution ou des opérations de boxe, comme indiqué ici: [35]
/ / Déclaration de la classe générique.
 
public class GenericList <T>{
    
Ajouter annuler (T entrée) {}}
 
classe TestGenericList{
    
classe ExampleClass privé {}
    
static void Main ()
    
{
        
/ / Déclaration d'une liste de type int.
        
GenericList <int> list1 = new GenericList <int> ();

        
/ / Déclaration d'une liste de type string.
        
GenericList <string> list2 = new <string> GenericList ();

        
/ / Déclarer une liste des types ExampleClass.
        
GenericList <ExampleClass> list3 = new <ExampleClass> GenericList ();
    
}}
Par rapport aux modèles C + +, C # génériques peuvent offrir une sécurité accrue, mais sont également sensiblement limité en capacités. [36] Par exemple, il n'est pas possible d'appeler les opérateurs arithmétiques dans une classe C # générique. [37]Préprocesseur
C # dispose d'"directives du préprocesseur" [38] (si elle ne dispose pas d'un préprocesseur réelle) basé sur le préprocesseur C qui permettent aux programmeurs de définir des symboles, mais pas de macros. Conditionnels tels que # if, # endif et # else sont également fournis. Directives telles que # region donner des conseils aux rédacteurs pour le pliage de code.
public class Foo{
    
# Region Constructeurs
    
publique Foo () {}
    
publique Foo (int firstParam) {}
    
# Endregion

    
# Procedures région
    
IntBar public void (int firstParam) {}
    
vide StrBar publique (chaîne firstParam) {}
    
publique vide BoolBar (bool firstParam) {}
    
# Endregion}
Les commentaires de code
C # utilise une double barre oblique (/ /) pour indiquer le reste de la ligne est un commentaire. Cela est hérité de C + +.
public class Foo{
    
/ / Un commentaire
    
Bar public static void (int firstParam) {} / / également un commentaire}
Commentaires sur plusieurs lignes peuvent commencer par slash-astérisque (/ *) et à la fin asterisk-slash (* /). Cela est héritée de la norme C.
public class Foo{
    
/ * A Multi-Line
       
commentaire * /
    
Bar public static void (int firstParam) {}}
Système de documentation XML
Système de documentation de C # est semblable à la Javadoc de Java, mais basé sur XML. Deux méthodes de documentation sont actuellement pris en charge par le compilateur C #.
Une seule ligne des commentaires de documentation, tels que ceux couramment dans Visual Studio code généré, sont indiqués sur une ligne commençant par / / /.
public class Foo{
    
/ / / <summary> Un résumé de la méthode. </ Summary>
    
/ / / <param Name="firstParam"> Une description du paramètre. </ Param>
    
/ / / Remarques <Remarks> sur la méthode. </ Remarques>
    
Bar public static void (int firstParam) {}}
Multi-ligne des commentaires de documentation, tandis que défini dans la spécification du langage version 1.0, ne sont pas pris en charge jusqu'à l'. NET version 1.1. [39] Ces commentaires commencent par slash-asterisk-astérisque (/ **) et à la fin asterisk-slash (* / ) [40].
public class Foo{
    
/ ** <summary> Un résumé de la méthode. </ Summary>
     
* <param Name="firstParam"> Une description du paramètre. </ Param>
     
* <Remarks> Remarques sur la méthode. </ Remarques> * /
    
Bar public static void (int firstParam) {}}
Notez qu'il ya des critères stricts concernant l'espace blanc et de documentation XML lorsque vous utilisez la barre oblique / asterisk / astérisque (/ **) technique.
Ce bloc de code:
/ **
 
* <summary>
 
* Un résumé de la méthode. </ Summary> * /
produit un commentaire XML différent de ce bloc de code suivant: [40]
/ **
 
* <summary>
   
Un résumé de la méthode. </ Summary> * /
Syntaxe des commentaires de documentation et leur balisage XML est défini dans une annexe non normative de l'ECMA C # standard. La même norme définit également des règles pour le traitement de ces commentaires, et leur transformation en un document XML simple avec des règles précises pour la cartographie de la CLI identifiants à leurs éléments de documentation connexes. Cela permet à tout autre outil de développement C # IDE ou trouver de la documentation pour n'importe quel symbole dans le code d'une certaine manière bien définie.Bibliothèques
Les détails C # de spécification d'un ensemble minimal de types et de bibliothèques de classes que le compilateur s'attend à disposer. Dans la pratique, C # est le plus souvent utilisé avec une certaine mise en œuvre du Common Language Infrastructure (CLI), qui est standardisé comme ECMA-335 Common Language Infrastructure (CLI).Exemple "Bonjour tout le monde"
Ce qui suit est un programme très simple C #, une version de l'exemple classique "Bonjour tout le monde":
using System;
 
Programme de classe{
    
static void Main ()
    
{
        
Console.WriteLine ("Bonjour tout le monde!");
    
}}
L'effet est d'écrire le texte suivant à la console de sortie:
Bonjour tout le monde!
Chaque ligne a un but:
using System;
La ligne au-dessus du code indique au compilateur d'utiliser le système comme un préfixe de candidat pour des types utilisés dans le code source. Dans ce cas, lorsque le compilateur voit l'utilisation du type de console plus tard dans le code source, il tente de trouver un type nommé console, d'abord dans l'assemblée actuelle, suivie par tous les assemblys référencés. Dans ce cas, le compilateur ne parvient pas à trouver un tel type, puisque le nom du type est en fait System.Console. Le compilateur tente alors de trouver un type nommé System.Console en utilisant le préfixe du système de l'instruction à l'aide, et cette fois elle réussit. L'instruction using permet au programmeur de déclarer tous les préfixes candidats à utiliser lors de la compilation au lieu de toujours utiliser des noms de type complet.
Programme de classe
Ci-dessus est une définition de classe. Tout entre la paire de bretelles qui suit décrit le programme.
static void Main ()
Ceci déclare la méthode de membre de classe où le programme commence à s'exécuter. L'. NET runtime appelle la méthode Main. (Note: principal peut également être appelé d'ailleurs, comme toute autre méthode, par exemple, d'un autre mode de programme.) Le mot-clé static rend la méthode accessible sans une instance de programme. Principal point d'entrée de chaque application console doit être déclarée statique. Sinon, le programme exigerait une instance, mais aucun cas, il faudrait un programme. Pour éviter que la dépendance circulaire insoluble, # compilateurs traitement des demandes de console C (comme celle ci-dessus) signaler une erreur, si il n'ya pas de méthode Main statique. Le mot-clé void déclare que le principal n'a pas de valeur de retour.
Console.WriteLine ("Bonjour tout le monde!");
Cette ligne écrit la sortie. Console est une classe statique dans l'espace de noms System. Il fournit une interface à l'entrée, de sortie et les flux d'erreur pour les applications de la console. Le programme appelle la méthode Console WriteLine, qui affiche sur la console d'un accord avec l'argument, la chaîne "Bonjour tout le monde!".
Un exemple GUI:
utilisant System.Windows.Forms;
 
Programme de classe{
    
static void Main ()
    
{
        
MessageBox.Show ("Bonjour tout le monde!");
    
}}
Cet exemple est similaire à l'exemple précédent, sauf qu'il génère une boîte de dialogue qui contient le message "Bonjour tout le monde!" au lieu de l'écrire dans la console.Normalisation et licences
En Août 2000, Microsoft Corporation, Hewlett-Packard et Intel Corporation ont co-parrainé la présentation du cahier des charges pour C # ainsi que le Common Language Infrastructure (CLI) aux standards organisation Ecma International. En Décembre 2001, les ECMA a publié la norme ECMA-334 C # Language Specification. C # est devenu une norme ISO en 2003 (ISO / IEC 23270:2003 - Technologies de l'information - Langages de programmation - C #). ECMA avait déjà adopté des spécifications équivalentes, la 2ème édition du C #, en Décembre 2002.
En Juin 2005, les ECMA approuvé édition 3 de la spécification C #, et mis à jour ECMA-334. Additions inclus classes partielles, les méthodes anonymes, les types NULL et génériques (similaire à templates C + +).
En Juillet 2005, les ECMA soumis aux normes et des référentiels liés à la norme ISO / IEC JTC 1 par procédure accélérée de ce dernier. Ce processus prend habituellement 6-9 mois.
La définition du langage C # et CLI sont normalisée en vertu des normes ISO et Ecma qui assurent la protection de licence raisonnable et non discriminatoire de revendications. Toutefois, Microsoft utilise C # et CLI dans sa bibliothèque de classes de base (BCL) qui est le fondement de son propriétaire. NET, et qui offre une variété de classes non normalisés (étendu des services Web d'E / S, l'interface graphique, etc ). Certains cas où les brevets de Microsoft s'appliquent aux normes utilisées dans le cadre. NET sont documentés par Microsoft et les brevets applicables sont disponibles soit sur les termes RAND ou par Open Specification Promise de Microsoft qui libère les droits de brevet auprès du public [41], mais il ya une certaine inquiétude et le débat quant à savoir si il ya des aspects supplémentaires brevetées par Microsoft qui ne sont pas couverts, ce qui peut décourager les implémentations indépendantes du cadre complet.
Microsoft a décidé de ne pas poursuivre les développeurs open source pour violation de brevets dans des projets à but non lucratif pour la partie du cadre qui est couvert par l'OSP. [42] Microsoft a également convenu de ne pas respecter les brevets relatifs aux produits Novell à l'encontre des clients payants de Novell [ 43], à l'exception d'une liste de produits qui ne mentionnent pas explicitement C #,. NET ou la mise en œuvre de Novell. NET (Le projet Mono). [44] Cependant, Novell soutient que Mono ne viole pas les brevets de Microsoft [45.] Microsoft a également conclu un accord spécifique de ne pas respecter les droits de brevet liées à l'extension de navigateur Moonlight, qui dépend de Mono, à condition qu'elle soit obtenue par Novell. [46]Implémentations
La référence compilateur C # est Microsoft Visual C #, qui est à sources fermées.
D'autres compilateurs C # existent, y compris souvent une mise en œuvre du Common Language Infrastructure et des bibliothèques de classes NET jusqu'à NET 2.0..:

    
Le projet Mono offre une open source du compilateur C #, une implémentation open source complète du Common Language Infrastructure, y compris les librairies du framework requis tels qu'ils apparaissent dans la spécification ECMA, et une mise en œuvre presque complète du propriétaire de Microsoft. Bibliothèques de classes NET jusqu'à. NET 3.5. Comme de Mono 2.6, pas de plans existent pour mettre en œuvre WPF, WF est prévu pour une version ultérieure;. Et il existe des implémentations partielles de LINQ to SQL et WCF [47]
    
Le projet DotGNU fournit également une open source du compilateur C #, une mise en œuvre presque complète de la Common Language Infrastructure, y compris les librairies du framework requis tels qu'ils apparaissent dans la spécification ECMA, et sous-ensemble d'une partie du restant propriétaire de Microsoft. Bibliothèques de classes NET jusqu'à. NET 2.0 (ceux distribution non documentés ou inclus dans la spécification ECMA, mais inclus dans le standard de Microsoft. NET Framework).
    
Projet Rotor de Microsoft (actuellement appelée Shared Source Common Language Infrastructure) (sous licence à des fins éducatives et de recherche uniquement) fournit une implémentation de source partagée de la runtime CLR et un compilateur C #, et un sous-ensemble du langage infrastructure des bibliothèques de cadre commun requises dans la spécification ECMA (jusqu'à C # 2.0, et pris en charge sur Windows XP uniquement).

Published By Drupal french Study