Types de données en DI#

Le langage DI# implémente plusieurs méthodes qui permettent de manipuler facilement les types de bases (string, int, etc.).

En DI#, chaque valeur manipulée possède un type de données qui détermine :

• les opérations possibles

• les méthodes disponibles

• la manière dont la valeur peut être affichée ou comparée

Bien comprendre les types permet d’éviter les erreurs courantes et d’écrire du code DI# plus robuste et maintenable.

Par souci de compatibilité avec les champs nullable du projet ou des tables relationnelles, certains de ces types supportent d’être assignés à Null. Toutefois, il est fortement déconseillé d’instancier ou d’utiliser des types nullable dans le code, afin de limiter les risques d’échecs d’exécution.

Note : Pour certains types (int, decimal, datetime), le langage DI# supporte des limites souvent plus grandes que celles des bases de données, il serait donc possible de créer une variable avec une valeur qui ne pourra pas être enregistrée dans la base de données par la suite. Consultez la documentation des projets / tables relationnelle pour connaître les limites de la base de données.

// Exemple pour chaque type  
string a = "texte"; 
int b = 1; 
decimal c = 1.234; 
datetime d1 = 2016.01.01 12:34:56; 
datetime d2 = 2016.01.01; 
bool e = true; // ou false ou null 
timespan g = 2.25; // 2 jours 6 heures 
datasource h = {1, 2, 3}; 	

Texte (string)

Chaîne de caractères Unicode, où un caractère est stocké sur 2 octets. La chaîne de caractères est délimitée par des guillemets ("). À l’intérieur d’une chaîne de caractère, le symbole \ agit comme caractère d’échappement pour symboliser des caractères spéciaux comme le retour de chariot (\r), le saut de ligne (\n) et autres.

// Exemples
[[  
string MonTexte = "ceci EST une chaîne de caractères ";  
MonTexte.Length; // Retourne le nombre 34 
MonTexte.Capitalize (true); // Retourne "Ceci EST Une Chaîne De Caractères "  
MonTexte.Capitalize(); // ou MonTexte.Capitalize(false); // Retourne la 
chaîne : "Ceci EST une chaîne de caractères "  
MonTexte.IndexOf("a"); // Retourne le nombre 15  
MonTexte.LastIndexOf("a"); // Retourne le nombre 26  
MonTexte.Left(12); // Retourne la chaîne : "ceci EST une"  
MonTexte.Right(12); // Retourne la chaîne : " caractères "  
MonTexte.Replace("une chaîne", "un test");  
// Retourne la chaîne : "ceci EST un test de caractères "  
MonTexte.Substring(12); // Retourne la chaîne : " chaîne de caractères "  
MonTexte.Substring(12, 3); // Retourne la chaîne : " ch"  
MonTexte.ToLower();  
// Retourne la chaîne : "ceci est une chaîne de caractères "   
MonTexte.ToUpper();  
// Retourne la chaîne : "CECI EST UNE CHAÎNE DE CARACTÈRES "  
MonTexte.Trim(); // Retourne "ceci EST une chaîne de caractères"  
]]

Notez que les valeurs retournées par ces méthodes et propriétés sont des valeurs du type approprié et que vous pouvez donc enchaîner des appels de méthodes ou accès aux propriétés du type retourné.

[[  
string MonTexte = "ceci EST une chaîne de caractère";  
MonTexte.Trim() .Replace ("une chaîne", "un test") .Capitalize(); 
// Retourne « Ceci EST un test de caractère »  
]]

Nombre entier (int)

Nombre entier 32 bits situé entre -2 147 483 648 et 2 147 483 647.

Nombre décimal (decimal)

Désigne tous les nombres à virgule flottante d’une très grande précision (28-29 chiffres significatifs). Le range se décrit techniquement comme suit : (-7.9x10²⁸)/(100²⁸) to (7.9x10²⁸)/(100²⁸)

Date et heure (datetime)

Représente la date et l’heure au format suivant :
• aaaa.MM.jj HH:mm:ss
• aaaa.MM.jj HH:mm
• aaaa.MM.jj

Notez qu’il ne s’agit pas d’une chaîne de caractères : une date ne doit pas être mise entre guillemets. Pour l’heure, si elle est omise complètement, l’heure attribuée est 00:00:00. Il en va de même pour les secondes : si les heures et minutes sont fournies sans les secondes, 0 secondes sera attribué.

[[  
datetime MyDate = 2016.01.01 12:34:56;  
MyDate.AddYears (3); // Résultat : 2019-01-01 12:34:56  
MyDate.AddMonths (3); // Résultat : 2016-04-01 12:34:56  
MyDate.AddDays (3); // Résultat : 2016-01-04 12:34:56  
MyDate.AddHours (3); // Résultat : 2016-01-01 15:34:56  
MyDate.AddMinutes (3); // Résultat : 2016-01-01 12:37:56  
MyDate.AddSeconds (3); // Résultat : 2016-01-01 12:34:59  
MyDate.DateDiff ("2014.03.03").Days; // Affiche 669  
MyDate.isDST (); // Affiche False  
MyDate.ToString (); // Affiche : 2016.01.01 12:34:56  
MyDate.ToString ("d/M/yyyy HH:mm:ss"); // Résultat : "1-1-2016 12:34:56"  
MyDate.ToString ("F"); // Résultat : "1 janvier 2016 12:34:56"  
MyDate.ToString ("ddd, dd MMM yyyy HH':'mm':'ss 'GMT' ");  
// Résultat : "ven., 01 janv. 2016 12:34:56 GMT"  
MyDate.Date; // Résultat : 2016-01-01 00:00:00  
MyDate.Day; // Résultat : 1  
MyDate.DayOfWeek; // Résultat : 5  
MyDate.DayOfYear; // Résultat : 1  
MyDate.Hour; // Résultat : 12  
MyDate.Minute; // Résultat : 34  
MyDate.Month; // Résultat : 1  
MyDate.Second; // Résultat : 56  
MyDate.Ticks; // Résultat : 635872484960000000  
MyDate.Year; // Résultat : 2016  
]]

Booléen (bool)

Un booléen représente une valeur de vérité. Il peut valoir TRUE ou FALSE.

Date et heure (timespan)

Contrairement à d'autres langages, timespan, en DI#, représente une durée de temps, soit un nombre de Jours, Heures, Minutes et Secondes. Ce type existe principalement pour faire des opérations sur le type « datetime ». Exemple : timespan t = date1 – date2 ; Note : pour assigner directement une valeur, il faut noter qu’on doit fournir une valeur décimale qui représente un nombre de jours (par exemple 2.25 = 2 jours 6 heures).

Source de données (datasource)

Datasource représente n’importe quel type de données « complexes », tel que les tableaux, les collections, les listes, les dictionnaires, etc. (équivalent à var en C# par exemple).

Un tableau en DI# est en fait une carte ordonnée. Une carte est un type qui associe des valeurs à des clés. Ce type est optimisé pour différentes utilisations ; il peut être considéré comme un tableau, une liste, une table de hashage, un dictionnaire, une collection, une pile, une file d'attente et probablement plus. On peut avoir, comme valeur d'un tableau, d'autres tableaux, multidimensionnels ou non. Autrement dit, on peut instancier un tableau de n’importe quel datatype qui serait soit fixe (voir les types listés ci-dessus), soit dynamique (équivalent à List<datatype> en .NET).

datasource myArray = { 1, 2, 3, "abc", "def" };

datasource myDictionary = { Prenom : "John", Nom : "Smith", Age : 30 };

// Les valeurs listées sont des Expressions, dont la valeur peut elle-même contenir une expression. On peut combiner les deux comme dans cet exemple :
datasource myArray =  
{  
    { Prenom : "Jean", Nom : "Tremblay", Age : 40 },  
    { Prenom : "John", Nom : "Smith", Age : 30 }  
}; 

string a[] = {"texte1", "texte2", "texte3"};  
int b[] = {1, 2, 3};  
decimal c[] = {1.111, 2.222, 3.333};  
datetime d[] = {2016.01.01 01:01:01, 2016.02.02 02:02:02, 2016.03.03 
03:03:03};  
bool e[] = {true, false, null};  
timespan g[] = {1472500, 1472500};  
datasource h[] = {123, "texte1", 1.111, 2016.01.01 01:01:01, true};

// On peut assigner des valeurs initiales en déclarant l'array
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
string b[] = { "texte 1", "test", "abc" };

// Supposons la source de données suivante :
[[  
datasource Vehicules =  
{  
{ Marque: "Toyota", Modele: "Sienna", Annee: 2015},  
{ Marque: "Ford", Modele: "Fusion", Annee: 2013},  
{ Marque: "Chevrolet", Modele: "Equinox", Annee: 2005 },  
{ Marque: "Hyundai", Modele: "Accent", Annee: 2016 },   
{ Marque: "Mazda", Modele: "CX-5", Annee: 2015 },  
{ Marque: "Hyundai", Modele: "Accent", Annee: 2010 },  
};
]] 

// Pour sélectionner toutes les marques de tous les véhicules :
[[  
datasource Marques =  select voiture.Marque  
                      from voiture in Vehicules;  
/* le tableau Marques contient :  
Toyota  
Ford  
Chevrolet  
Hyundai  
Mazda  
Hyundai  
*/  
]] 

// Pour sélectionner toutes les marques uniques (sans doublon) de tous les véhicules :
[[  
datasource Marques =  select distinct voiture.Marque  
                      from voiture in Vehicules;  
/* 
le tableau Marques contient :  
Toyota  
Ford  
Chevrolet  
Hyundai  
Mazda  
*/  
]]

/* Pour sélectionner toutes les marques uniques (sans doublon) de tous les véhicules ordonnés du modèle le plus récent au plus ancien :
*/
[[  
datasource Marques =  select distinct voiture.Marque  
                      from voiture in Vehicules  
                      order by (voiture.Annee desc);  
/*  
le tableau Marques contient :  
Hyundai  
Mazda  
Toyota  
Ford  
Chevrolet  
*/  
]] 

/* Pour sélectionner toutes les marques uniques (sans doublon) de tous les
 véhicules ordonnés du modèle le plus récent au plus ancien, en excluant les
 modèles avant 2014 :
*/
[[
 datasource Marques = select distinct voiture.Marque
 from voiture in Vehicules
 where (voiture.Annee > 2014)
 order by (voiture.Annee desc);
 /*
 le tableau Marques contient :
 Hyundai
 Mazda
 Toyota
 */
 ]

// Note : il est possible de cloner un tableau en sélectionnant tous items de ce dernier :
[[  
datasource VehiculesCopie =  select voiture from voiture in Vehicules;  
]]