Apprentissage des bases de la syntaxe C #
Contrairement à Python, en C # Semicolon est obligatoire après chaque déclaration. Le compilateur indiquerait une erreur si nous n'utilisions pas de point-virgule. En langue C #, nous devons importer les bibliothèques pertinentes pour utiliser les fonctions intégrées. Mais si nous codons dans Visual Studio et créons un framework C #, il n'est pas nécessaire d'importer une bibliothèque car les bibliothèques existeront déjà dans notre code lorsque nous créons un package. Et ils seront flous mais lorsque nous utiliserons n'importe quelle méthode d'une classe spécifique, l'IDE modifiera automatiquement la couleur du texte et la rendra visible dans le code. Chaque fois que nous utilisons un autre IDE pour le codage C #, nous devons l'écrire manuellement. IDE est l'abréviation d'un environnement de développement intégré et nous permet de coder dans une langue particulière. Pour C # codage L'IDE le plus utilisé et la plus fiable est le code Visual Studio.
La syntaxe du langage C # est très bien ordonnée et maintenue, chacune est lisible et claire. Le code n'importera aucun fichier supplémentaire ni n'inclura de variables inutiles car elle ne nous permet pas de définir des variables inutiles qui existent mais jamais utilisées dans le programme. Et si nous déclarons une variable mais ne l'utilisons pas tout au long du code, il continuera à indiquer que la variable est déclarée mais non utilisée.
Syntaxe de l'exemple 1:
Dans cet exemple, nous n'utiliserons qu'un seul espace de noms dans le code. Et couvrons chaque détail que vous devez connaître sur la syntaxe C # et l'exécution à partir de zéro.
Code:
Utilisation du système;
Programme d'espace de noms_0
classe de classe
statique void main (String [] args)
Console.WriteLine ("Ceci est le premier code!");
Sortir:
Explication du code
Passons en profondeur chaque ligne du code ci-dessus, comment cela fonctionne et pourquoi nous en avons besoin dans notre code.
Utilisation du système:
L'énoncé `` Using System '' indique au compilateur que nous utilisons le système: c'est un espace de noms dont nous discuterons en détail, mais ici vous devez simplement comprendre qu'avant d'utiliser quoi que ce soit dans le code, nous devons dire au compilateur que nous utilisons le système de notre programme. Lorsque nous créons un package ou un projet, nous devons d'abord écrire cette déclaration. Cette déclaration nous permet d'utiliser tout ce que le système a. Nous pouvons facilement accéder à toutes les classes et méthodes intégrées du système, sans écrire le mot «système» encore et encore. Comme si nous voulons montrer quelque chose sur la console, nous utiliserons la console.Fonction écrite (). Nous appelons cette fonction d'une telle manière console.Écriture () lorsque nous écrivons «Utilisation du système» au début du code. Mais lorsque l'instruction «Utilisation du système» n'est pas mentionnée au début, nous utiliserons une fonction comme le système.Console.Écrire(). Nous devons inclure le mot «système» avec toute fonction système que nous utilisons. Mais en utilisant l'instruction «Utilisation du système» au début du code, nous pouvons gagner du temps.
Ligne blanche
Le codage en langue C # est bien géré des classes à l'indentation. Le compilateur s'occupe de tout. Les espaces blancs sont ignorés par C #, l'ajout de lignes vierges supplémentaires rend le code plus facile à comprendre sans affecter le fonctionnement du code. Ils jouent un rôle important et améliorent la lisibilité du code. Après l'instruction «Utilisation du système», la ligne vierge est utilisée pour séparer la partie des bibliothèques d'importation de l'autre code.
Espace de noms
Le terme «espace de noms» fonctionne comme un conteneur qui contient le code principal, les classes et les fonctions. Dans un projet, nous pouvons avoir plus d'un «espace de noms». Et en dehors de cet «espace de noms», nous pouvons également définir d'autres espaces de noms. Mais pour ce faire, nous devons les définir en utilisant «Namespace_name», qui montre le nom du nouvel espace de noms créé. Nous utilisons toujours «Espace de noms» avec le nom de la classe auquel nous voulons accéder dans le code. Par défaut, le nom du projet que nous avons créé se voit attribuer le nom «Espace de noms». Nous pouvons le changer, mais pour cela, nous devons mettre à jour le nom du dossier. Il organise les membres de données d'un espace de noms comme une classe, mais dans «l'espace de noms», nous pouvons avoir plus d'une classe. Lorsqu'un «espace de noms» est créé dans un projet, il contient un nom de classe «programme», nous pouvons modifier ce nom qui s'appelle un membre de la classe d'espace de noms. Et à l'intérieur de la classe, nous avons une méthode appelée méthode membre de l'espace de noms.
Accolades
Dans les accolades bouclées d'un espace de noms, nous écrivons le code principal. Le code à l'intérieur de l'espace de noms comprend les classes, les fonctions et les instances de classes. Un espace de noms peut contenir un autre espace de noms, qui s'appelle un espace de noms imbriqué. Les méthodes ou les membres d'un espace de noms sont accessibles en utilisant l'espace de noms avec un point. Ce faisant, nous pouvons appeler n'importe quelle fonction: namespace_1.MyProgram (). Le compilateur accédera ensuite à l'espace de noms que nous avons mentionné dans le code, le point indiquera au compilateur que nous voulons accéder à sa méthode ou à son membre et après le point spécifie le nom d'une méthode à laquelle nous voulons accéder.
Classe
Une classe est un organisateur à l'intérieur de l'espace de noms qui organisera les membres de données et les méthodes des membres. Une classe contient différents types de données et méthodes en un seul endroit qui peuvent être accessibles par les objets de la classe. Le langage C # fournit une classe intégrée où nous pouvons utiliser plusieurs méthodes. Mais une méthode principale sera utilisée pour appeler toutes les méthodes ou classes. En C #, il est possible d'avoir une classe à l'intérieur d'une autre classe; Ceci est connu comme l'héritage. Ce concept de classes est appelé programmation orientée objet (OOP) dans laquelle nous créons des objets d'une classe. Dans la POO, nous avons différentes méthodes comme l'encapsulation pour cacher les données, un héritage qui augmente la sécurité et héritant des données sous la forme d'une relation parent-enfants, un parent peut avoir de nombreux enfants mais un enfant n'a qu'un seul parent, l'abstraction et un beaucoup d'autres. En C #, les classes sont plus importantes car si nous voulons ajouter deux nombres, nous le faisons avec l'aide de classes car elle a une classe lorsque nous créons un projet. Tout ce que nous faisons est à l'intérieur d'une classe.
Méthode Main ()
Un programme n'a qu'une seule méthode Main (). Dans cette méthode Main (), nous appelons tous les objets et fonctions, nous pouvons attribuer des valeurs et effectuer des opérations. Nous pouvons créer de nombreuses classes et espaces de noms, mais l'espace de noms créé avec le projet aura une classe. Dans cette classe, nous invoquons la méthode principale (). Tout ce qui est présenté sur l'écran de sortie est dû à cette méthode, les objets que nous avons appelés dans la méthode principale () affichent des données supplémentaires mais les méthodes ne seront pas visibles sur l'écran de sortie. En C #, nous pouvons appeler plus d'une méthode Main (), mais pour ce faire, nous devons dire au compilateur quelle méthode main () sera exécutée et compilée. Pour cela, nous devons compiler en tant que compilation startupObject.
Console
La console est l'écran de sortie; c'est la classe de l'espace de noms du système. Il est utilisé pour afficher les messages et la valeur des variables sur l'écran de sortie. La console a de nombreuses méthodes car c'est une classe, il a donc des méthodes intégrées que nous pouvons utiliser en appelant simplement la méthode avec le nom de classe, Console.WriteLine (). Ici, «Console» montre le nom d'une classe qui utilise l'espace de noms système et WriteLine () est la méthode de cette classe que nous utilisons. Une chose importante à noter ici est que si nous n'utilisons pas l'instruction «Utilisation du système» au début du code, nous devons toujours inclure le terme «système» avec le nom de la fonction lors de l'appel d'une méthode de l'espace de noms système. Cela indique au compilateur qu'il s'agit d'une classe de système et que nous utilisons une méthode spécifique de cette classe. De nombreuses méthodes sont intégrées dans le système afin que nous puissions facilement y accéder. Il comprend la console.ReadLine (), console.Write (), console.BackgroundColor () et bien plus encore que nous pouvons utiliser pour apporter des modifications à notre console. Toutes les méthodes de la classe «console» sont intégrées pour faire des variations dans la console.
Syntaxe de l'exemple 2:
Ici, nous employons plus d'un espace de noms dans notre code pour démontrer comment il fonctionne lorsqu'il y a plusieurs espaces de noms.
Code:
Utilisation du système;
Espace de noms One_1
classe publique Myone
public static void Onemethod ()
Console.WriteLine ("Ceci est ma classe de namespace one_1");
Programme d'espace de noms_1
programme de classe
statique void main (String [] args)
un 1.Mon seul.OneMethod ();
Console.WriteLine ("Ceci est un programme de noms programme_1");
Explication du code:
Nous allons maintenant apprendre comment nous pouvons créer des espaces de noms dans le C # de nos choix. Il y a déjà un espace de noms créé dans le C # ide lorsque nous créons un projet, il définit automatiquement un environnement pour nous à coder en C # Langue. Nous pouvons créer plusieurs espaces de noms si nous pensons que nous avons besoin d'un autre espace de noms pour séparer une partie du code de l'autre.
Dans ce programme, nous créerons un autre espace de noms pour vous montrer comment cela fonctionne. Le programme créé sera enregistré en tant que «programme_1» et le C # définira un environnement avec un espace de noms, une classe et une méthode Main (). Ensuite, nous avons créé un espace de noms de 'One_1'. À l'intérieur de cet espace de noms, nous avons créé une classe publique parce que nous ne pouvons pas faire de codage dans l'espace de noms sans définir la classe. Nous devons donc définir un nom de classe «myone». Au sein de cette classe, nous pouvons invoquer plusieurs méthodes, mais ici, nous appelons une seule fonction pour réduire la complexité du code et rendre les choses simples et faciles à comprendre. La fonction OneMethod () est appelée à l'intérieur de la classe «Myone». Ensuite, nous avons utilisé une méthode de classe système de «console» de l'espace de noms pour représenter un message sur le terminal. La console.La fonction writeLine () montre le texte 'Ceci est la classe Myone de l'espace de noms One_1' tandis que WriteLine () envoie le curseur à la ligne suivante après imprimer le message. Maintenant, allez dans l'espace de noms 'programme_1' créé par l'environnement système. À l'intérieur du «programme» de classe, la méthode Main () appelle la méthode d'espace de noms OneMethod (). Lorsque nous invoquons une fonction d'un espace de noms dans la méthode principale (), nous l'écrivons de cette manière. Namespace_name.nom du cours.Method_name (); Dans le code, nous implémentons cette fonction comme One_1.Mon seul.OneMethod (). Ici, l'attribut 'One_1' est le nom de l'espace de noms, 'Myone' montre la classe de cet espace de noms et OneMethod () est le nom d'une méthode. Après cela, la console.La fonction writeLine () est appliquée pour imprimer la déclaration «Ceci est un programme d'espace de noms_1» sur le terminal.
Voyons comment ce code fonctionne. Le compilateur commencera à compiler à partir de la méthode principale (). La première instruction de la méthode principale () sera exécutée en premier, il ira dans l'espace de noms 'One_1'. Ensuite, il ira à la classe «myone» de cet espace de noms et exécutera la fonction OneMethod () de cette classe. Le OneMethod () n'a qu'une seule instruction qui sera implémentée, puis le contrôle reviendra dans la méthode principale () et exécutera l'instruction suivante. Ainsi, nous recevrons un message sur le terminal.
Sortir:
L'écran de sortie affichera deux messages sur la console, l'un de l'espace de noms par défaut et l'autre de l'espace de noms qui sera créé. La première déclaration dans la fonction principale () serait exécutée d'abord, puis l'instruction suivante sera exécutée. Ces deux déclarations imprimeront deux messages en appelant la console.Fonction écrite ().
Conclusion
Nous avons discuté de la syntaxe de base du C # en détail. Cet article contient tout ce que vous devez savoir avant de coder en langue C #. Cette langue est sensible à la casse, et le point-virgule est important pour mettre fin à chaque déclaration. Vous pouvez obtenir une erreur si vous oubliez de mettre le point-virgule. Dans l'espace de noms C #, les classes sont très importantes, ils gardent le code organisé. Nous pouvons définir différents espaces de noms pour séparer une partie du code de l'autre. Avec un certain nombre d'exemples, la syntaxe de base de C # a été approfondie. En un mot, la syntaxe de C # est un peu différente des autres langues mais elle est plus fiable et lisible. Mais une fois que vous comprenez sa syntaxe, le codage en C # devient beaucoup plus facile pour vous.