Les tableaux sous Delphi .NET

La classe Array est la classe de base pour les implémentations du langage qui prennent en charge 
les tableaux. Cependant, seuls les compilateurs et le système peuvent dériver explicitement de la 
classe Array. 
Les utilisateurs doivent employer les constructions de tableaux fournies par le langage.

Const Nbitem=9;

type
 TArrayStatic = Array[0..Nbitem] of Byte;
 TArrayDynamiqueSimple = Array of Byte;

var
  TableauStatic:TArrayStatic;
  TableauDynamique: TArrayDynamiqueSimple;

begin
  TableauDynamique := New(TArrayDynamiqueSimple, 15);
  // Identique à
  //  TableauStatic:=New(TArrayDynamiqueSimple,15);
  TableauStatic:=TableauDynamique; // Recopie de tableau
end.

type
 TArrayDynamiqueSimple = Array of Byte;
 
var 
  Tb1,Tb2 : TArrayDynamiqueSimple;
begin
  ...
  Tb1:= New(TArrayDynamiqueSimple, 4);
  Tb2:= New(TArrayDynamiqueSimple, 7);
  Tb1:=Tb2;

type
 TArrayDynamiqueObjet = Array of TObject;
 TArrayDynFileStream= Array of System.IO.FileStream;
var 
  TabObjet,TFS:  system.Array; 
begin
   TabObjet:=TArrayDynFileStream(TFS.Clone); // Le transtypage se fait sur le résultat de la méthode

TabObjet:=TArrayDynamiqueObjet(system.Array(TFS).Clone);

TabObjet:=Copy(TArrayDynFileStream(TFS));

Const Nbitem=9;

type
 TArrayStatic = Array[0..Nbitem] of Byte;
 TArrayDynamiqueSimple = Array of Byte;

var
 I : Byte;
 Tableau : TArrayStatic;

begin
 // Initialisation par boucle en connaissant la taille
 for I:=0 to Nbitem do
  begin
   Tableau[I]:=I;
  end;

  // Initialisation via un itérateur
 For I in Tableau do
  begin
   Tableau[I] := I;
  end;

  // Pour initialiser un tableau à zéro, similaire à Fillchar sous Win32
  // Pour un tableau statique Initialize est traduit en un appel à l'instruction IL newarr
 Initialize(Tableau);

  // Pour initialiser un tableau avec une valeur particulière, ici  0
 &Array.Clear(Tableau,0,Length(Tableau));

  //Initialisation par boucle sans connaitre la taille
 For I := 0 to Pred(Length(Tableau)) do 
  begin 
   Tableau[I] := I; 
  end;
end.

type
 TArrayDynamiqueSimple = Array of Byte;

var
  Simple: TArrayDynamiqueSimple;

begin
 Simple:=TArrayDynamiqueSimple.Create(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
end.

Const
 nbItem=9;

type
  TArrayDynamiqueSimple = Array of Byte;

var
  Simple: TArrayDynamiqueSimple;

begin
  Simple := New(TArrayDynamiqueSimple, 10);
  for I:=0 to nbItem do
   Simple[I]:=I;
end.

type
 TArrayDynamiqueSimple = Array of Byte;

var
  TableauDynamique: TArrayDynamiqueSimple;

begin
   // Alloue 256 octets. Array[0..255], initialisés à zéro
  // Première forme : le type d'élément et la taille du tableau
  TableauDynamique := New(TArrayDynamiqueSimple, 256);
  Write('Valeur de TableauDynamique[0] =',TableauDynamique[0]);
  Writeln(' Nombre d''éléments=', System.Array(TableauDynamique).GetLength(0).ToString);

  // Alloue 1 octet. Array[0..0], initialisé à 255
  // Seconde forme : le type d'élément et une liste d'initialiseurs de tableaux.
  TableauDynamique := New(array[] of byte,(255));
  Write('Valeur de TableauDynamique[0] =',TableauDynamique[0]);
  Writeln(' Nombre d''éléments=', System.Array(TableauDynamique).GetLength(0).ToString);
  Readln;
end.

Valeur de TableauDynamique[0] =0    Nombre d'élément=256
Valeur de TableauDynamique[0] =255  Nombre d'éléments=1

C: array [] of TPoint;    // tableau de TPoint

begin
   // New prenant une liste d'initialiseurs de TPoint.
 C := New(array[] of TPoint, ((X:1;Y:2), (X:3;Y:4)) );

Contrairement à la plupart des classes, Array fournit la méthode CreateInstance plutôt que des constructeurs
publics, permettant ainsi l'accès à liaison tardive.

var
  // On peut utiliser System.Array si le type du tableau est inconnu à la compilation
  Simple: TArrayDynamiqueSimple; 

   // CreateInstance attend 2 tableaux d'entier (à une dimension)
  LowerBounds,
  Lengths : TIntegerDynArray;

begin
   // Création des 2 tableaux nécessaires
  LowerBounds:= New(TIntegerDynArray,1);  // Contient les bornes inférieures
  Lengths:=New(TIntegerDynArray,1); // Contient la longueur d'une dimension
 
  // Initialisation des valeurs
  LowerBounds[0]:=1; // Bornes inférieures
  Lengths[0]:=10;    // Longueur

   //Création du tableau souhaité : Array [1..10] Of Byte
  Simple:=System.Array.CreateInstance(typeof(Byte),Lengths,LowerBounds) as TArrayDynamiqueSimple;
end.

   //Création du tableau souhaité : Array [1..10] Of Byte
  Simple:=System.Array.CreateInstance(Typeof(Byte),
                 New(array[] of integer,(10)),
                 New(array[] of integer,(1))) as TArrayDynamiqueSimple;

TableauDynamiqueSimple := New(TArrayDynamiqueSimple,-256);
 Writeln('TableauDynamiqueSimple négatif');
 ShowInfoTableau(TableauDynamiqueSimple);

Nombre total d'éléments dans toutes les dimensions = 0
Nombre de dimensions  = 1
Nombre d'éléments(0) = 0
GetLowerBound(0)     = 0
GetUpperBound(0)     = -1

   // Alloue 256 octets. Array[-256..-1]
  LowerBounds:= TArrayDynamiqueInteger.Create(-256); // Déclare 1 dimensions et indique le premier indice
  Lengths:=TArrayDynamiqueInteger.Create(256);       // Déclare la longueur du tableau [-256..-1]
  TableauDynamiqueObjet:=System.Array.CreateInstance(typeof(Byte),Lengths,LowerBounds);
  Writeln('TableauDynamiqueSimple négatif');
  ShowInfoTableau(TableauDynamiqueObjet);

Nombre total d'éléments dans toutes les dimensions = 256
Nombre de dimensions  = 1
Nombre d'éléments(0) = 256
GetLowerBound(0)     = -256
GetUpperBound(0)     = -1

System.Byte[]

System.Byte[*]

type
 TArrayStatic = Array[0..9] of Byte;

type
  TArrayDynamique= Array of Byte;

Function IsSZArray(Origine:System.Array):Boolean;
 // Renvoie True si le tableau est un tableau simple, une dimension  basé zéro
 //  Un tableau de tableau est considéré comme un tableau simple
 //  Un tableau de System.String est considéré comme un tableau simple
Begin
  Result:=(Origine.Rank=1) And (Origine.GetLowerBound(0)=0);
end;

Function IsArrayOfArray(Origine:System.Array):Boolean;
 // renvoie true si le tableau est un tableau de tableau
 // Array of String renvoie faux, bien que String soit un Array of Char
 //
 // Provoque une exception NullReferenceException si une dimension du tableau Origine n'est pas initialisée
var Tableau: System.Array;
begin
 Result:=False;
  // Si Origine est un tableau d'objet on ne le considère pas, au vu de sa définition, comme
  // un tableau de tableau.
 If Not (Origine.GetType.GetElementType=TypeOf(System.Object)) then
   // Détermine le Type de l'objet auquel le tableau en cours fait référence.
  if Origine.GetType.GetElementType.IsArray then
   Result:=True;
end;

Function GetNestedLevel(Origine:System.Array):Byte;
 // Renvoie la 'profondeur d'un tableau de tableau
 // Array of byte       = 1
 // Array of Array byte = 2 ...
 //
 // Si une dimension du tableau Origine n'est pas initialisée cela provoquera
 // une exception NullReferenceException dans la méthode IsArrayOfArray
type
 TableauD2 =Array[0..0,0..0] of TObject;
 TableauD3 =Array[0..0,0..0,0..0] of TObject;

begin
 Result:=1;
 While IsArrayOfArray(Origine) do
 begin
  case Origine.Rank of
      //Array[0..0]
   1: Origine:=System.Array(Origine[Origine.GetLowerBound(0)]);
       //Array[0..0,0..0]
   2: Origine:=System.Array(TableauD2(Origine)[Origine.GetLowerBound(0),
                                               Origine.GetLowerBound(1)]);
       //Array[0..0,0..0,0..0]
   3: Origine:=System.Array(TableauD3(Origine)[Origine.GetLowerBound(0),
                                               Origine.GetLowerBound(1),
                                               Origine.GetLowerBound(2)]);
   // Pour les autres dimensions -> erreur
  end;
  Inc(Result);
 end;
end;

Il se peut que Type.IsArray et Type.GetElementType ne retournent pas les résultats attendus avec Array,
car si un tableau est casté en type Array, le résultat est un objet, et non pas un tableau.
Cela signifie que typeof(System.Array).IsArray retourne false et que typeof(System.Array).GetElementType
retourne une référence nil.

Function IsAnArray(Origine:TObject):Boolean;
var TabType :System.Type;
begin
 TabType:=Origine.GetType;
 Result:=TabType.IsArray; // Origine.GetType.IsArray est possible;
end;

Procedure ShowBound(Origine:System.Array);
var S : String;
    I : Byte;
begin
 with Origine do
  for i:=0 to Rank-1 do
   begin
    Writeln('Type d''élément du tableau : '+ GetType.GetElementType.ToString);
    Writeln('Taille fixe : '+IsFixedSize.ToString);
    Writeln('Nombre de dimensions = '+Rank.ToString);
    S:=I.ToString;
    Writeln('Nombre d''éléments('+S+') = '+GetLength(I).ToString);
    Writeln('GetLowerBound('+S+')      = '+GetLowerBound(I).ToString);
    Writeln('GetUpperBound('+S+')      = '+GetUpperBound(I).ToString);
   end;
end;

Procedure ShowInfoTableau(Origine:System.Array);
begin
 with Origine do
  begin
    Writeln('Variable tableau '+IsAnArray(Origine).ToString);
    Writeln('Niveau d''imbrication '+GetNestedLevel(Origine).ToString);
    Writeln('Tableau de tableau : '+ IsArrayOfArray(Origine).ToString);
    Writeln('Type du tableau : '+GetType.ToString);
    Writeln('CLS-Compliant '+ Boolean(GetLowerBound(0)=0).ToString);
    Writeln('Tableau simple : '+Boolean(IsSZArray(Origine)).ToString);
    Writeln('Taille : '+ IntToStr(SizeOf(Origine) ));
    Writeln('nombre total d''éléments dans toutes les dimensions = '+Length.ToString);
    ShowBound(Origine)
  end;
end;

public abstract class Array : ICloneable, IList
 {
   ...
   public virtual bool IsReadOnly {
    get { return false; }
   }
 ...

public abstract class Array : ICloneable, IList
 {
   ...
  public virtual bool IsFixedSize {
   get { return true; }
  }
 ...