Page d'Accueil

Les types de données intégrales

 

Introduction

Le langage C# (actuellement .NET Framework) traite chaque type de données primitif comme classe. En fait, chaque type de données a été créé comme structure. Certaines caractéristiques sont communes à plusieurs de ces structures tandis que quelques autres aspects sont uniques par rapport aux autres.

Pour soutenir les opérations courantes des variables régulières, chaque structure qui représente un type primitif est équipée de quelques membres variables et méthodes.

 

Conversion en chaîne de caractères

Avec une valeur d'un type primitif, à un moment ou à un autre, vous pouvez devoir convertir la valeur d'une variable de son type en chaîne de caractères. Pour soutenir ceci, chaque structure d'un type primitif est équipée d'une méthode appelée ToString. Cette méthode est prise en charge dans diverses versions. Une des versions de cette méthode ne prend aucun argument. La syntaxe de cette méthode est :

public override string ToString();

Une autre version de cette méthode prend comme argument une chaîne de caractères. Cette chaîne juge une expression utilisée pour composer la valeur de la variable qui a fait appel à la méthode. La syntaxe de cette méthode est :

public string ToString(string format);

Dans la leçon 5, nous avons vu comment vous pouvez passer la chaîne désirée pour composer la valeur à afficher.

Analyse d'une chaîne de caractères

Dans la leçon 5, nous avons vu comment recouvrer une valeur de la console et la convertir en valeur désirée. Pour soutenir cette opération, chaque structure d'un type de données primitif est équipée d'une méthode statique appelée Parse. Les syntaxes de cette méthode sont:

byte
public static byte Parse(string s);
sbyte
public static sbyte Parse(string s);
short
public static short Parse(string s);
ushort <=> UInt16
public static ushort Parse(string s);
int <=> Int32
public static int Parse(string s);
uint <=> UInt32
public static uint Parse(string s);
long <=> Int64
public static long Parse(string s);
unsigned long <=> uint64
public static ulong Parse(string s);

Voici un exemple d'appeler cette méthode :

using System;

class Program
{
    static int Main()
    {
        double value = 0;

        Console.Write("Enter a Value: ");
        value = double.Parse(Console.ReadLine());

        Console.WriteLine("Value Entered: {0}", value);

        return 0;
    }
}

Voici un exemple d'exécution du programme :

Enter a Value: 245.85
Value Entered: 245.85
Press any key to continue . . .

Vous pouvez également analyser une valeur qui n'est pas connue d'avance. Pour soutenir des valeurs autres que les types byte, vous pouvez utiliser une autre version de la méthode Equals() qui prend comme argument un type d'objet. Les syntaxes de cette version de la méthode sont:

byte
public static byte Parse(string s)
sbyte
public static sbyte Parse(string s)
short
public static short Parse(string s)
ushort <=> UInt16
public static ushort Parse(string s)
int <=> Int32
public static int Parse(string s)
uint <=> UInt32
public static uint Parse(string s)
long <=> Int64
public static long Parse(string s)
unsigned long <=> uint64
public static ulong Parse(string s)

En faisant appel à cette méthode, si une mauvaise valeur est passée à la méthode Parse (), par exemple si l'utilisateur écrit une valeur inadmissible à double. Parse (Console.ReadLine ()) appelée, le programme produit une erreur (dans la leçon 17, nous apprendrons que le programme rejette une exception). Pour vous aider avec ce type de problème, chaque structure d'un type primitif est équipée d'une méthode appelée TryParse. Cette méthode est prise en charge dans deux versions ou chacune renvoie un bool. Une des versions de cette méthode prend deux arguments : une chaîne et une variable passées comme référence out. Les syntaxes de cette méthode sont:

byte
public static bool TryParse(string s, out byte result)
sbyte
public static bool TryParse(string s, out sbyte result)
short
public static bool TryParse(string s, out short result)
ushort <=> UInt16
public static bool TryParse(string s, out ushort result)
int <=> Int32
public static bool TryParse(string s, out int result)
uint <=> UInt32
public static bool TryParse(string s, out uint result)
long <=> Int64
public static bool TryParse(string s, out long result)
unsigned long <=> uint64
public static bool TryParse(string s, out ulong result)

Basé sur ceci, si une variable double appelle cette méthode, le premier argument est passé à une chaîne et le deuxième argument est passé comme un out double. Ceci signifie que le deuxième argument est également retourné à la méthode .

Quand la méthode TryParse () est appelée :

  • Si le premier argument passé à la méthode est valide, la méthode renvoie deux valeurs : vrai et la valeur entrée est stockée dans l'argument out
  • Si la valeur du premier argument est inadmissible, la méthode renvoie faux et la valeur par défaut du type de données est stockée dans l'argument out. Par exemple, si la variable qui a appelé la méthode est du type int mais l'utilisateur a entré une valeur fausse, la méthode renvoie deux valeurs : faux et 0 (parce que 0 est la valeur par défaut d'un int). Si la variable qui a appelé la méthode est de type char mais l'utilisateur a entré une mauvaise valeur, la méthode renvoie deux valeurs : faux et un caractère vide (parce que la valeur par défaut d'un char est un vide). 

Voici un autre exemple d'exécution du programme ci-dessus :

Enter a Value: 506GH
False: Value Entered = 0
Press any key to continue . . .

Notez que le compilateur n'a pas produit (de rejet) une erreur (une exception).

Les valeurs minimum et maximum d'un type primitif

Dans la leçon 1, nous avons vu que, quand vous déclarez une variable, le compilateur réserve une quantité d'espace mémoire préparant à stocker sa valeur. Comme différentes variables ont différentes conditions, certaines d'entre elles utilisent plus ou moins de mémoire que d'autres. Quand vous déclarez une variable, le type de données que vous indiquez permet au compilateur de savoir l'espace de mémoire qui serait nécessaire pour stocker la valeur de cette variable. Il y a des valeurs minimum et maximum qui peuvent être stockées dans l'espace mémoire réservé à une variable. Basé sur ceci, une valeur telle que 224855 peut être stockée dans l'espace réservé à une variable int mais il est au delà de l'espace réservé pour un byte ou un short.

Pour vous aider à découvrir la valeur minimum qu'un type de données peut contenir, chaque structure d'un type primitif est équipée d'un membre constant appelé MinValue. De la même manière, la valeur maximum qu'un type de données peut soutenir est représentée par un champ constant appelé MaxValue. Vous pouvez vérifier ces minimum et maximum avec le programme suivant :

using System;

class Program
{
    static int Main()
    {
        Console.WriteLine(
	"=======================================================================");
        Console.WriteLine("C# Type .NET Structure Minimum         Maximum");
        Console.WriteLine(
	"=======================================================================");
        Console.WriteLine("char    Char           {0}\t\t\t{1}",
				char.MinValue, char.MaxValue);
        Console.WriteLine(
	"-----------------------------------------------------------------------");
        Console.WriteLine("byte    Byte           {0}\t\t\t{1}",
				 byte.MinValue, byte.MaxValue);
        Console.WriteLine(
	"-----------------------------------------------------------------------");
        Console.WriteLine("sbyte   SByte          {0}\t\t\t{1}",
				 sbyte.MinValue, sbyte.MaxValue);
        Console.WriteLine(
	"-----------------------------------------------------------------------");
        Console.WriteLine("short   Int16          {0}\t\t\t{1}",
				 short.MinValue, short.MaxValue);
        Console.WriteLine(
	"-----------------------------------------------------------------------");
        Console.WriteLine("ushort  UInt16         {0}\t\t\t{1}",
				 UInt16.MinValue, UInt16.MaxValue);
        Console.WriteLine(
	"-----------------------------------------------------------------------");
        Console.WriteLine("int     Int32          {0}\t\t{1}",
				 int.MinValue, int.MaxValue);
        Console.WriteLine(
	"-----------------------------------------------------------------------");
        Console.WriteLine("uint    UInt32         {0}\t\t\t{1}",
				 UInt32.MinValue, UInt32.MaxValue);
        Console.WriteLine(
	"-----------------------------------------------------------------------");
        Console.WriteLine("long    Int64          {0}\t{1}",
				 long.MinValue, long.MaxValue);
        Console.WriteLine(
	"-----------------------------------------------------------------------");
        Console.WriteLine("uint64  UInt64         {0}\t\t\t{1}",
				 UInt64.MinValue, UInt64.MaxValue);
        Console.WriteLine(
	"-----------------------------------------------------------------------");
        Console.WriteLine("float   Single         {0}\t\t{1}",
				 float.MinValue, float.MaxValue);
        Console.WriteLine(
	"-----------------------------------------------------------------------");
        Console.WriteLine("double  Double         {0}\t{1}",|
				 double.MinValue, double.MaxValue);
        Console.WriteLine(
	"-----------------------------------------------------------------------");
        Console.WriteLine("decimal Decimal        {0} {1}",
				 decimal.MinValue, decimal.MaxValue);
        Console.WriteLine(
	"=============================================================");

        return 0;
    }
}

Ceci produirait :

=======================================================================
C# Type .NET Structure Minimum                  Maximum
=======================================================================
char    Char                                    ?
-----------------------------------------------------------------------
byte    Byte           0                        255
-----------------------------------------------------------------------
sbyte   SByte          -128                     127
-----------------------------------------------------------------------
short   Int16          -32768                   32767
-----------------------------------------------------------------------
ushort  UInt16         0                        65535
-----------------------------------------------------------------------
int     Int32          -2147483648              2147483647
-----------------------------------------------------------------------
uint    UInt32         0                        4294967295
-----------------------------------------------------------------------
long    Int64          -9223372036854775808     9223372036854775807
-----------------------------------------------------------------------
uint64  UInt64         0                        18446744073709551615
-----------------------------------------------------------------------
float   Single         -3.402823E+38            3.402823E+38
-----------------------------------------------------------------------
double  Double         -1.79769313486232E+308   1.79769313486232E+308
-----------------------------------------------------------------------
decimal Decimal        -79228162514264337593543950335 79228162514264337593543950335
=============================================================
Press any key to continue . . .

Comparaison de valeurs

Une des opérations les plus communes a exécuté sur des variables consiste à comparer leurs valeurs : pour découvrir si elles sont égales ou pour savoir si une est plus grande que l'autre. Ces opérations peuvent être effectuées en utilisant les opérateurs booléens que nous avons passés en revue dans la leçon 8. Les opérations booléennes font partie du langage C#. Pour les mettre formellement en application, chaque structure d'un type de données est équipée d'une méthode appelée CompareTo qui est prise en charge dans deux versions.

Une des réalisations de la méthode CompareTo () compare une valeur ou la valeur d'une variable de même type que la variable qui appelle la méthode. Cette méthode prend un argument qui est de même type que la variable qui l'appelle. Les syntaxes de cette méthode sont:

byte
public int CompareTo(byte value)
sbyte
public int CompareTo(sbyte value)
short
public int CompareTo(short value)
ushort <=> UInt16
public int CompareTo(ushort value)
int <=> Int32
public int CompareTo(int value)
uint <=> UInt32
public int CompareTo(uint value)
long <=> Int64
public int CompareTo(long value)
unsigned long <=> uint64
public int CompareTo(ulong value)

La méthode renvoie une valeur int. Par exemple, imaginer que vous avez deux variables int appelées Variable1 et Variable2, vous pouvez appeler la méthode CompareTo() de la première variable pour comparer sa valeur à celle de la deuxième variable. Ceci serait fait comme dans :

int result = Variable1.CompareTo(Variable2);

Le résultat à la fin serait comme suit :

  • Si la valeur de la Variable1 est plus grande que la valeur de la Variable2, la méthode retourne 1 
  • Si la valeur de la Variable1 est plus petite que la valeur de la Variable2, la méthode retourne  -1
  • Si les valeurs des deux variables sont égales, la méthode retourne 0 

Voici un exemple :

using System;

class Program
{
    static int Main()
    {
        int Variable1 = 248;
        int Variable2 = 72937;
        int result = Variable1.CompareTo(Variable2);
        Console.WriteLine("{0} compared to {1} produces {2}",
                          Variable1, Variable2, result);

        return 0;
    }
}

Ceci produirait :

248 compared to 72937 produces -1
Press any key to continue . . .

Une autre version de la méthode CompareTo () vous permet de comparer la valeur d'une variable à une variable dont le type n'est pas identique à la variable qui l'a appelé. Puisque tous les types et classes de C# sont basés sur l'objet, cette deuxième version prend comme argument un objet objet. Le retour de la méthode est une valeur int. La syntaxe de cette version est :

public int CompareTo(object value);

Notez que vous pouvez utiliser la méthode CompareTo () pour déterminer l'égalité. Une autre méthode vérifiant l'égalité de deux variables est la méthode Equals (). La méthode Equals () est prise en charge dans deux versions et chacune prend un argument. La méthode Equals () renvoie une valeur booléenne. Une des versions de cette méthode prend comme argument une valeur de même type que la variable qui l'a appelé. Les syntaxes de cette version sont:

byte
public bool Equals(byte obj)
sbyte
public bool Equals(sbyte obj)
short
public bool Equals(short obj)
ushort <=> UInt16
public bool Equals(ushort obj)
int <=> Int32
public bool Equals(int obj)
uint <=> UInt32
public bool Equals(uint obj)
long <=> Int64
public bool Equals(long obj)
unsigned long <=> uint64
public bool Equals(ulong obj)

La méthode compare les valeurs de la variable qui a l'a appelé et l'argument, comme dans

bool result = Variable1.Equals(Variable2);

La comparaison est effectuée comme suit :

  • Si la valeur de la première variable est identique à celle de la deuxième variable, la méthode renvoie vrai
  • Si les valeurs des variables sont différentes, la méthode renvoie faux

Voici un exemple :

using System;

class Program
{
    static int Main()
    {
        int  Variable1 = 1407;
        int  Variable2= 59266;
        bool result = value1.Equals(value2);
        Console.WriteLine("{0} = {1} produces {2}",
            Variable1, Variable2, result);

        return 0;
    }
}

Ceci produirait :

1407 = 59266 produces False
Press any key to continue . . .

L'autre version de la méthode Equals () prend comme argument une valeur objet. La syntaxe de cette version est :

public override bool Equals(object obj);

Voici un exemple :

using System;

class Program
{
    static int Main()
    {
        int    value1 = 824;
        object value2 = 824;
        bool result = value1.Equals(value2);
        Console.WriteLine("{0} = {1} produces {2}",
            value1, value2, result);

        return 0;
    }
}

Ceci produirait :

824 = 824 produces True
Press any key to continue . . .
  

Page d'Accueil Copyright © 2007-2008, Yevol