Classes intégrées : Objet

Introduction

C# a été clairement créé pour améliorer C++ et pour offrir probablement une nouvelle alternative. Pour réaliser ce but, Microsoft a créé une bibliothèque énorme pour accompagner le langage. .NET Framework est une bibliothèque énorme faite de diverses classes et constantes que vous pouvez directement utiliser dans votre application C# sans charger nécessairement explicitement une bibliothèque externe. Pour commencer, cette bibliothèque principale de C# fournit une classe appelée Object.

Comme vous avez pu déjà réalisé, chaque variable ou fonction dans C# (comme dans Java) doit appartenir à une classe, à la différence de C/C++ où vous pouvez avoir des variables ou des fonctions globales. Par conséquent, vous devez toujours créer au moins une classe pour votre application. En tant que tels, quand vous créez une classe, elle hérite automatiquement de ses caractéristiques primaires du parent de toutes les classes : Objet.

1. Commencez Microsoft Visual C# et créez une application de console appelée Sport1
2. Pour créer une nouvelle classe, dans Explorateur de solution, droit-cliquez Sport1 - > Ajouter - > classe…
3. Placer le nom Sport et cliquez Ajouter
4. Changez le fichier comme suit :
    

   using System; namespace Sport1 { class Sport { private double _ballWeight; private int _players; private double _courtLength; private double _courtWidth; public double BallWeight { get { return _ballWeight; } set { _ballWeight = value; } } public int NumberOfPlayers { get { return _players; } set { _players = value; } } public double CourtLength { get { return _courtLength; } set { _courtLength = value; } } public double CourtWidth { get { return _courtWidth; } set { _courtWidth = value; } } } }

5. Accédez au fichier Program.cs et changez le comme suit :
    

   using System; namespace Sport1 { class Program { static int Main() { Sport tennis = new Sport(); tennis.BallWeight = 57.50; // grams tennis.NumberOfPlayers = 1; // Singles game tennis.CourtLength = 23.70; // meters tennis.CourtWidth = 8.23; // meters; Console.WriteLine("Sport Characteristics"); Console.WriteLine("Ball Weight: {0} grams", tennis.BallWeight); Console.WriteLine("Players on each side: {0}", tennis.NumberOfPlayers); Console.WriteLine("Court Dimensions(LxW): {0}m X {1}m\n", tennis.CourtLength, tennis.CourtWidth); return 0; } } }

6. Exécutez l'application :
    

   Sport Characteristics Ball Weight: 57.5 grams Players on each side: 1 Court Dimensions(LxW): 23.7m X 8.23m Press any key to continue . . .

7. Fermez la fenêtre DOS

Quand vous déclarez et initialisez deux variables, une des opérations que vous voudrez subséquement effectuer est de comparer leur valeur. Pour soutenir cette opération, la classe objet fournit ses enfants d'une méthode appelée Equals. La méthode Equals () vient dans deux versions. Le premier a la syntaxe suivante :

public virtual bool Equals(object obj);

Cette version vous permet d'appele la rméthode Equals () sur une variable déclarée et de passer l'autre variable comme argument. Voici un exemple :

Ceci produirait :

The first and the second books have different number of pages
The first and the third books have the same number of pages

La première version de la méthode Object.Equals est déclarée comme virtuelle, qui signifie que vous pouvez la passer si vous créez votre propre classe. La deuxième version de la méthode Object.Equals () est :

public static bool Equals(object obj2, object obj2);

Comme une méthode statique, pour l'utiliser, vous pouvez passer les variables des deux classes dont les valeurs que vous voulez comparer.

Dans les deux cas, si les valeurs des variables sont semblables, la méthode Equals () renvoie vrai. Si elles sont différentes, la méthode renvoie faux. Si vous utilisez la méthode Equals () pour comparer les variables de deux types primitifs, la comparaison devrait être franche. Si vous voulez utiliser ces méthodes sur des variables déclarées de votre propre classe, vous devriez fournir votre propre exécution de cette méthode.

Étude pratique : Mettre en application l'égalité

Ficeler une classe

Dans des leçons précédentes, nous avons appris que, pour convertir la valeur d'une variable déclarée d'un type primitif en chaîne de caractères, vous pourriez appeler la fonction ToString(). Voici un exemple :

using System;

class BookCollection
{
    static int Main()
    {
	int NumberOfPages = 422;
	
        Console.WriteLine("Number of Pages: {0}", NumberOfPages.ToString());
    }
}

Dans beaucoup de langages de programmation tels que C++, les programmeurs habituellement doivent surcharger un opérateur (extracteur) pour afficher les valeurs de la variable des classes à l'écran. La classe objet fournit une alternative à cette solution légèrement compliquée, par la méthode ToString (). Sa syntaxe est :

public virtual string ToString();

Bien que la classe objet fournisse cette méthode en tant que non abstrait, sa version mise en application est plus utile si vous utilisez un type primitif tel que int, double et leurs variances ou une variable chaîne de caractères string. La meilleure manière de compter là-dessus consiste à le dépasser dans votre propre classe si vous désiriez utiliser son rôle.

Étude pratique : Convertir en chaîne de caractères

Boxing et Un-Boxing

En étudiant la succession, nous  avons appris que tous les types de données utilisés dans le programme de C# « sont basés sur » un objet appelé objet. Comme présenté plus tôt, vous pouvez utiliser ce type de données pour déclarer une variable qui contiendrait n'importe quel type de valeur. Puisque c'est un type « universel » de type de données, il peut également être initialisé avec n'importe quelle valeur. Voici les exemples :

using System;

class Exercise
{
    static void Main()
    {
	object Number = 244;
	object Thing  = "Professor Kabba";

	Console.WriteLine(Number);
	Console.WriteLine(Thing);
    }
}

Ceci produirait :

244
Professor Kabba

Comme vous pouvez voir, quand une variable objet est initialisée, le compilateur découvre le type de valeur qui lui a été assignée. Ceci est désigné sous le nom de boxing. Ce mécanisme est d'une manière transparente fait dans C# (et dans Visual Basic mais pas dans Visual C++ 2003 (il est possible que quelque chose soit faite pour dans la prochaine version, ou pas)).

Si vous déclarez une variable en utilisant un type de données primitif (int, float, double, etc.), en même temps, vous pouvez être intéressé à convertir la valeur de cette variable en objet. Voici un exemple :

using System;

class Exercise
{
    static void Main()
    {
	int Number = 244;
	object Thing  = Number;

	Console.WriteLine(Number);
	Console.WriteLine(Thing);
    }
}

Ceci produirait :

244
244

Cette opération est désigné sous le nom de unboxing. Comme vous pouvez voir, cette opération est effectuée d'une manière transparente (Visual C++ 2003 ne la fait pas d'une manière transparente).

Boxing et unboxing font de C# un langage très flexible et merveilleux (si vous abusez de lui, naturellement qu'il peut être dangereux).

Tandis qu'un constructeur, créé pour chaque classe, est utilisé pour installer une classe. La classe objet fournit la méthode Finalize () comme type de destructeur.

  Le namespace system fournit une des plus grande définition des classes du .NET Framework, mais il ne contient pas tout. Par exemple, quand vous commencerez à écrire des applications graphiques de l'interface utilisateur (GUI), vous devrez utiliser d'autres namespaces. Les namespaces sont contenus dans les bibliothèques appelées les assemblées. Les classes réelles utilisées dans diverses applications sont créées et définies dans ces bibliothèques. Avant d'utiliser une classe, vous devez savoir le nom de l'assemblée dans laquelle elle est définie. Vous devez également savoir le nom de son namespace. Ces trois informations, le nom de la classe, le namespace dans lesquelles elle est définie, et le nom de l'assemblée dans laquelle le namespace est contenu, sont très importantes. Puisqu'il y a tant de classes, de namespaces, et de bibliothèques, la documentation de MSDN est votre meilleure référence. Nous pouvons seulement mentionner quelques uns, particulièrement ceux qui sont appropriés pour les sujets que nous passons en revue.