C # est un langage de programmation moderne, polyvalent et orienté objet développé par Microsoft. C # est conçu pour Common Language Infrastructure (CLI), qui se compose du code exécutable et de l'environnement d'exécution qui permet l'utilisation de divers langages de haut niveau sur différentes plates-formes et architectures informatiques.

Un tableau Jagged est un tableau de tableaux.

Vous pouvez initialiser un tableau dentelé comme -

int[][] scores = new int[2][]{new int[]{92,93,94},new int[]{85,66,87,88}};

Où, scores est un tableau de deux tableaux d'entiers - scores [0] est un tableau de 3 entiers et scores [1] est un tableau de 4 entiers.

Il existe trois façons de transmettre des paramètres à une méthode -

• Value parameters- Cette méthode copie la valeur réelle d'un argument dans le paramètre formel de la fonction. Dans ce cas, les modifications apportées au paramètre à l'intérieur de la fonction n'ont aucun effet sur l'argument.

• Reference parameters- Cette méthode copie la référence à l'emplacement mémoire d'un argument dans le paramètre formel. Cela signifie que les modifications apportées au paramètre affectent l'argument.

• Output parameters - Cette méthode permet de renvoyer plus d'une valeur.

Oui! Utilisation des paramètres de sortie. Une instruction return peut être utilisée pour renvoyer une seule valeur à partir d'une fonction. Cependant, à l'aide des paramètres de sortie, vous pouvez renvoyer deux valeurs à partir d'une fonction.

Les paramètres de sortie sont similaires aux paramètres de référence, sauf qu'ils transfèrent les données hors de la méthode plutôt que dedans. Le paramètre de référence copie la référence à l'emplacement mémoire d'un argument dans le paramètre formel. Cela signifie que les modifications apportées au paramètre affectent l'argument.

Un espace de noms est conçu pour fournir un moyen de séparer un ensemble de noms d'un autre. Les noms de classe déclarés dans un espace de noms ne sont pas en conflit avec les mêmes noms de classe déclarés dans un autre.

using keyword est utilisé pour inclure un espace de noms dans le programme. Un programme a généralement plusieurs instructions using.

Les variables de type valeur peuvent recevoir une valeur directement. Ils sont dérivés de la classe System.ValueType.

Les types valeur contiennent directement des données. Certains exemples sont int, char et float, qui stockent respectivement des nombres, des alphabets et des nombres à virgule flottante. Lorsque vous déclarez un type int, le système alloue de la mémoire pour stocker la valeur.

Les types de référence ne contiennent pas les données réelles stockées dans une variable, mais ils contiennent une référence aux variables.

En d'autres termes, ils font référence à un emplacement mémoire. En utilisant plusieurs variables, les types de référence peuvent faire référence à un emplacement mémoire. Si les données de l'emplacement mémoire sont modifiées par l'une des variables, l'autre variable reflète automatiquement ce changement de valeur. Des exemples de types de référence intégrés sont: objet, dynamique et chaîne.

Le type d'objet est la classe de base ultime pour tous les types de données dans C # Common Type System (CTS). Object est un alias de la classe System.Object. Les types d'objet peuvent se voir attribuer des valeurs de tous autres types, types de valeur, types de référence, types prédéfinis ou définis par l'utilisateur. Cependant, avant d'attribuer des valeurs, il faut une conversion de type.

Lorsqu'un type de valeur est converti en type d'objet, il est appelé boxe.

Lorsqu'un type d'objet est converti en type valeur, cela s'appelle unboxing.

Vous pouvez stocker n'importe quel type de valeur dans la variable de type de données dynamique. La vérification de type pour ces types de variables a lieu au moment de l'exécution.

La syntaxe pour déclarer un type dynamique est -

dynamic <variable_name> = value;

Par exemple,

dynamic d = 20;

Les types dynamiques sont similaires aux types d'objets, sauf que la vérification de type pour les variables de type d'objet a lieu au moment de la compilation, tandis que celle des variables de type dynamique a lieu au moment de l'exécution.

Les variables de type pointeur stockent l'adresse mémoire d'un autre type. Les pointeurs en C # ont les mêmes capacités que les pointeurs en C ou C ++.

La syntaxe pour déclarer un type de pointeur est -

type* identifier;

Par exemple

char* cptr;
int* iptr;

L'opérateur is détermine si un objet est d'un certain type.

If (Ford is Car) // vérifie si Ford est un objet de la classe Car.

en tant qu'opérateur lance sans lever d'exception si la conversion échoue.

Object obj = new StringReader("Hello");
StringReader r = obj as StringReader;

L'encapsulation est définie «comme le processus consistant à enfermer un ou plusieurs éléments dans un package physique ou logique». L'encapsulation, dans la méthodologie de programmation orientée objet, empêche l'accès aux détails d'implémentation.

L'encapsulation est implémentée à l'aide de spécificateurs d'accès.

Un spécificateur d'accès définit la portée et la visibilité d'un membre de classe.

Le spécificateur d'accès public permet à une classe d'exposer ses variables membres et ses fonctions membres à d'autres fonctions et objets. Tout membre public est accessible depuis l'extérieur de la classe.

Le spécificateur d'accès privé permet à une classe de masquer ses variables membres et ses fonctions membres à d'autres fonctions et objets. Seules les fonctions de la même classe peuvent accéder à ses membres privés. Même une instance d'une classe ne peut pas accéder à ses membres privés.

Le spécificateur d'accès protégé permet à une classe enfant d'accéder aux variables membres et aux fonctions membres de sa classe de base. De cette façon, cela aide à implémenter l'héritage.

Le spécificateur d'accès interne permet à une classe d'exposer ses variables membres et ses fonctions membres à d'autres fonctions et objets de l'assembly actuel. En d'autres termes, tout membre avec un spécificateur d'accès interne est accessible à partir de n'importe quelle classe ou méthode définie dans l'application dans laquelle le membre est défini.

Le spécificateur d'accès interne protégé permet à une classe de masquer ses variables membres et ses fonctions membres à d'autres objets et fonctions de classe, à l'exception d'une classe enfant dans la même application. Ceci est également utilisé lors de l'implémentation de l'héritage.

C # fournit des types de données spéciaux, les types Nullable, auxquels vous pouvez attribuer une plage normale de valeurs ainsi que des valeurs Null.

Par exemple, vous pouvez stocker n'importe quelle valeur comprise entre -2 147 483 648 et 2 147 483 647 ou null dans une variable Nullable <Int32>. De même, vous pouvez affecter true, false ou null dans une variable Nullable <bool>.

L'opérateur de fusion null est utilisé avec les types valeur Nullable et les types référence. Il est utilisé pour convertir un opérande en type d'un autre opérande de type valeur Nullable (ou non), où une conversion implicite est possible.

Si la valeur du premier opérande est nulle, alors l'opérateur renvoie la valeur du deuxième opérande, sinon il renvoie la valeur du premier opérande.

En utilisant le mot-clé params, un paramètre de méthode peut être spécifié qui prend un nombre variable d'arguments ou même aucun argument.

Non! les paramètres supplémentaires ne sont pas autorisés après le mot clé params dans une déclaration de méthode. Un seul mot clé params est autorisé dans une déclaration de méthode.

La classe Array est la classe de base pour tous les tableaux en C #. Il est défini dans l'espace de noms System. La classe Array fournit diverses propriétés et méthodes pour travailler avec des tableaux.

Utilisation de la fonction Array.sort (array). Il trie les éléments d'un tableau unidimensionnel entier en utilisant l'implémentation IComparable de chaque élément du tableau.

Triez d'abord le tableau en utilisant Array.sort (array), puis inversez le même en utilisant la méthode Array.reverse (array).

En C #, une structure est un type de données de type valeur. Il vous aide à faire en sorte qu'une seule variable contienne des données liées de différents types de données. Le mot-clé struct est utilisé pour créer une structure.

Les structures sont utilisées pour représenter un enregistrement. Pour définir une structure, vous devez utiliser l'instruction struct. L'instruction struct définit un nouveau type de données, avec plus d'un membre pour votre programme.

Les classes et les structures présentent les différences fondamentales suivantes -

• les classes sont des types de référence et les structs sont des types valeur.

• les structures ne prennent pas en charge l'héritage.

• les structures ne peuvent pas avoir de constructeur par défaut.

Une énumération est un ensemble de constantes entières nommées. Un type énuméré est déclaré à l'aide du mot clé enum.

Les énumérations C # sont du type de données valeur. En d'autres termes, l'énumération contient ses propres valeurs et ne peut pas hériter ou ne peut pas transmettre l'héritage.

Le spécificateur d'accès par défaut pour un type de classe est interne.

L'accès par défaut pour les membres est privé.

L'un des concepts les plus importants de la programmation orientée objet est l'héritage. L'héritage nous permet de définir une classe en termes d'une autre classe, ce qui facilite la création et la maintenance d'une application. Cela permet également de réutiliser la fonctionnalité du code et d'accélérer le temps de mise en œuvre.

Lors de la création d'une classe, au lieu d'écrire des membres de données et des fonctions membres complètement nouveaux, le programmeur peut désigner que la nouvelle classe doit hériter des membres d'une classe existante. Cette classe existante est appelée la classe de base et la nouvelle classe est appelée la classe dérivée.

L'idée d'héritage met en œuvre la relation IS-A. Par exemple, le mammifère EST un animal, le chien IS-A, le mammifère, donc le chien IS-A également, et ainsi de suite.

Non! C # ne prend pas en charge l'héritage multiple.

Une classe peut être dérivée de plusieurs classes ou interfaces, ce qui signifie qu'elle peut hériter des données et des fonctions de plusieurs classes de base ou interfaces. La syntaxe utilisée en C # pour créer des classes dérivées est la suivante -

<acess-specifier> class <base_class>
{
   ...
}
class <derived_class> : <base_class>
{
   ...
}

Le mot polymorphisme signifie avoir de nombreuses formes. Dans le paradigme de la programmation orientée objet, le polymorphisme est souvent exprimé comme «une interface, plusieurs fonctions».

Le polymorphisme peut être statique ou dynamique. Dans le polymorphisme statique, la réponse à une fonction est déterminée au moment de la compilation. Dans le polymorphisme dynamique, il est décidé au moment de l'exécution.

C # fournit deux techniques pour implémenter le polymorphisme statique. Ils sont -

• Surcharge de fonction

• Surcharge de l'opérateur

Le mécanisme de liaison d'une fonction à un objet pendant la compilation est appelé liaison anticipée. Il est également appelé liaison statique.

Vous pouvez avoir plusieurs définitions pour le même nom de fonction dans la même portée. La définition de la fonction doit différer les unes des autres par les types et / ou le nombre d'arguments dans la liste d'arguments. Vous ne pouvez pas surcharger les déclarations de fonction qui diffèrent uniquement par le type de retour.

Le polymorphisme dynamique est implémenté par des classes abstraites et des fonctions virtuelles.

Lorsqu'une classe est déclarée scellée, elle ne peut pas être héritée.

Non! Il ne peut pas être créé car les classes abstraites ne peuvent pas être déclarées scellées.

Lorsque vous avez une fonction définie dans une classe que vous souhaitez implémenter dans une ou plusieurs classes héritées, vous utilisez des fonctions virtuelles. Les fonctions virtuelles pourraient être implémentées différemment dans différentes classes héritées et l'appel à ces fonctions sera décidé au moment de l'exécution.

Vous pouvez redéfinir ou surcharger la plupart des opérateurs intégrés disponibles en C #. Ainsi, un programmeur peut également utiliser des opérateurs avec des types définis par l'utilisateur.

Les opérateurs surchargés sont des fonctions avec des noms spéciaux, l'opérateur mot-clé suivi du symbole de l'opérateur en cours de définition. Semblable à toute autre fonction, un opérateur surchargé a un type de retour et une liste de paramètres.

n interface est définie comme un contrat syntaxique que toutes les classes héritant de l'interface doivent suivre. L'interface définit la partie «quoi» du contrat syntaxique et les classes dérivées définissent la partie «comment» du contrat syntaxique.

Les interfaces définissent les propriétés, les méthodes et les événements, qui sont les membres de l'interface. Les interfaces contiennent uniquement la déclaration des membres. Il est de la responsabilité de la classe dérivée de définir les membres. Cela aide souvent à fournir une structure standard que les classes dérivantes suivraient.

Les directives du préprocesseur donnent l'instruction au compilateur de prétraiter les informations avant le début de la compilation réelle.

Toutes les directives de préprocesseur commencent par # et seuls les caractères d'espace blanc peuvent apparaître avant une directive de préprocesseur sur une ligne. Les directives du préprocesseur ne sont pas des instructions, elles ne se terminent donc pas par un point-virgule (;).

Vous pouvez utiliser la directive #if pour créer une directive conditionnelle. Les directives conditionnelles sont utiles pour tester un symbole ou des symboles afin de vérifier s'ils sont évalués à vrai. S'ils évaluent à vrai, le compilateur évalue tout le code entre le #if et la directive suivante.

Les exceptions C # sont représentées par des classes. Les classes d'exception en C # sont principalement dérivées directement ou indirectement de la classe System.Exception. Certaines des classes d'exception dérivées de la classe System.Exception sont les classes System.ApplicationException et System.SystemException.

La classe System.ApplicationException prend en charge les exceptions générées par les programmes d'application. Par conséquent, les exceptions définies par les programmeurs devraient dériver de cette classe.

La classe System.SystemException est la classe de base pour toutes les exceptions système prédéfinies.