Page d'Accueil

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.

Étude pratiqueÉtude pratique : Présentation de l'ancêtre des classes 

  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

Égalité de deux variables classe

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 :

using System;

class BookCollection
{
    static void Main()
    {
	// First book
	int NumberOfPages1 = 422;
	// Second book
	int NumberOfPages2 = 858;
	// Third book
	int NumberOfPages3 = 422;

	if( NumberOfPages1.Equals(NumberOfPages2) == true )
            Console.WriteLine("The first and the second books have the same number of pages");
	else
	    Console.WriteLine("The first and the second books have different number of pages");
			
	if( NumberOfPages1.Equals(NumberOfPages3) == true )
	    Console.WriteLine("The first and the third books have the same number of pages");
	else
	    Console.WriteLine("The first and the third books have different number of pages");
    }
}

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Étude pratique : Mettre en application l'égalité

  1. Accédez au fichier Sport.cs
  2. Pour créer votre propre exécution de la méthode Equals (), changez le fichier comme suit :
     
    using System;
    
    namespace Sport1
    {
        class Sport
        {
            . . .
    
            public double CourtWidth
            {
                get { return _courtWidth; }
                set { _courtWidth = value; }
            }
    
            public override bool Equals(Object obj)
            {
                Sport sp = (Sport)obj;
    
                if ((_ballWeight == sp._ballWeight) &&
                    (_players == sp._players) &&
                    (_courtLength == sp._courtLength) &&
                    (_courtWidth == sp._courtWidth))
                    return true;
    
                return false;
            }
        }
    }
  3. Accédez au fichier Program.cs et changez le comme suit :
     
    using System;
    
    namespace Sport1
    {
        class Program
        {
            static int Main()
            {
                Sport Euro2002 = new Sport();
                Sport CAN2004 = new Sport();
                Sport tennis = new Sport();
    
                Euro2002.BallWeight = 435; // grams
                Euro2002.NumberOfPlayers = 11;  // persons for each team
                Euro2002.CourtLength = 100; // meters
                Euro2002.CourtWidth = 60;  // meters
    
                tennis.BallWeight = 57.50; // grams
                tennis.NumberOfPlayers = 1;     // Singles game
                tennis.CourtLength = 23.70; // meters
                tennis.CourtWidth = 8.23;  // meters;
    
                CAN2004.BallWeight = 435; // grams
                CAN2004.NumberOfPlayers = 11;  // persons for each team
                CAN2004.CourtLength = 100; // meters
                CAN2004.CourtWidth = 60;  // meters
    
                if (CAN2004.Equals(tennis) == true)
                    Console.WriteLine("The CAN2004 and the tennis variables are equal");
                else
                    Console.WriteLine("The Euro2002 and the tennis variables are not equal");
    
                if (Euro2002.Equals(CAN2004) == true)
                    Console.WriteLine("The Euro2002 and CAN2004 variables are equal");
                else
                    Console.WriteLine("The Euro2002 and CAN2004 variables are not equal");
    
                return 0;
            }
        }
    }
  4. Exécutez l'application. Ceci produirait :
     
    The Euro2002 and the tennis variables are not equal
    The Euro2002 and CAN2004 variables are equal
    Press any key to continue . . .
  5. Fermez la fenêtre DOS

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Étude pratique : Convertir en chaîne de caractères

  1. Accédez au fichier Sport.cs
  2. Pour appliquer et utiliser une méthode ToString (), 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; }
            }
    
            public override bool Equals(Object obj)
            {
                Sport sp = (Sport)obj;
    
                if ((_ballWeight == sp._ballWeight) &&
                        (_players == sp._players) &&
                    (_courtLength == sp._courtLength) &&
                    (_courtWidth == sp._courtWidth))
                    return true;
    
                return false;
            }
    
            public override string ToString()
            {
                string person = null;
    
                if (NumberOfPlayers.Equals(1))
                    person = " person";
                else
                    person = " persons";
    
                string result = "\nBall Weight:           " + BallWeight + " grams" +
                            "\nPlayers on each side:  " + NumberOfPlayers + person +
                                "\nCourt Dimensions(LxW): " +
                                 CourtLength + "m X " + CourtWidth + "m";
    
                return result;
            }
        }
    }
  3. Accédez au fichier Program.cs et changez le comme suit :
     
    using System;
    
    namespace Sport1
    {
        class Program
        {
            static int Main()
            {
                Sport CAN2004 = new Sport();
                Sport tennis = new Sport();
    
                tennis.BallWeight = 57.50; // grams
                tennis.NumberOfPlayers = 1;     // Singles game
                tennis.CourtLength = 23.70; // meters
                tennis.CourtWidth = 8.23;  // meters;
    
                CAN2004.BallWeight = 435;   // grams
                CAN2004.NumberOfPlayers = 11;    // persons for each team
                CAN2004.CourtLength = 100;   // meters
                CAN2004.CourtWidth = 60;    // meters
    
                Console.WriteLine("====================================");
                Console.WriteLine("Cup Game Characteristics");
                Console.Write("------------------------------------");
                Console.WriteLine(CAN2004);
    
                Console.WriteLine("\n====================================");
    
                Console.WriteLine("Tennis Game Characteristics");
                Console.Write("------------------------------------");
                Console.WriteLine(tennis);
                Console.WriteLine("\n====================================");
    
                return 0;
            }
        }
    }
  4. Exécutez l'application. Ceci produirait :
     
    ====================================
    Cup Game Characteristics
    ------------------------------------
    Ball Weight:           435 grams
    Players on each side:  11 persons
    Court Dimensions(LxW): 100m X 60m
    
    ====================================
    Tennis Game Characteristics
    ------------------------------------
    Ball Weight:           57.5 grams
    Players on each side:  1 person
    Court Dimensions(LxW): 23.7m X 8.23m
    
    ====================================
    Press any key to continue . . .
  5. Fermez la fenêtre DOS

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).

Finaliser une variable

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.

Autres classes intégrées

  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.

  

Page d'Accueil Copyright © 2007, Yevol