Les tableaux sous Delphi .NET

public abstract class Array : ICloneable, IList
 {
   ...

  public virtual IEnumerator GetEnumerator()
  {
      int lowerBound = GetLowerBound(0);
      if (Rank == 1 && lowerBound == 0)
          return new SZArrayEnumerator(this);
      else
          return new ArrayEnumerator(this, lowerBound, Length);
  }
 ...

Const 
 Nbitem=9;

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

var
  TableauStatic:TArrayStatic;
  
begin
 {$R-}
  I:=10;
  try
   TableauStatic[I]:=0;
  except
   On E:ERangeError do   // Est déclenchée avec R+, mais pas avec R-
    Writeln('Avec R+ : ERangeError '+E.Message);
   On E:System.IndexOutOfRangeException do // Est déclenchée avec R-, mais pas avec R+
    Writeln('Avec R- : System.IndexOutOfRangeException '+E.Message);
  end;

{$R-}
  Chaine:='1234';
  Caractere:=Chaine[5]; // Déclenche System.IndexOutOfRangeException avec R+ ou R-
  Chaine[5]:='A'; // Déclenche System.ArgumentOutOfRangeException avec R+ ou R-
  Writeln(Caractere);
  Writeln(Chaine);

Les instructions MSIL (Microsoft Intermediate Language) suivantes lèvent IndexOutOfRangeException  :
- ldelem.<type> : load an element of an array
- ldelema       : load address of an element of an array
- stelem.<type> : store an element of an array

type
  TArrayDynamiqueSimple = Array of Byte;

var
  TableauDynamique: TArrayDynamiqueSimple;

begin
   // Alloue 256 octets. Array[0..255]
  TableauDynamique := New(TArrayDynamiqueSimple, 256);
end.

  ...
  IL_0006:  ldc.i4     0x100
  IL_000b:  newarr     [mscorlib]System.Byte
  IL_0010:  stloc.0
  ...

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

var
  TableauStatic:TArrayStatic;

begin
  Writeln('TArrayStatic');
  ShowInfoTableau(TableauStatic); // Appel implicite au code IL <b>newarr</b>
  Writeln;
end.

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.

IL_0006:  ldc.i4.s   10
  IL_0008:  newarr     [mscorlib]System.Byte
  IL_000d:  stloc.0
  IL_000e:  ldc.i4.s   10
  IL_0010:  newarr     [mscorlib]System.Byte
  IL_0015:  stloc.1  
  ... // code de préparation d'appel
  IL_0024:  call       void [mscorlib]System.Array::Copy(class [mscorlib]System.Array,
                                                         class [mscorlib]System.Array,
                                                         int32)
  ...

Procedure CreeDynamique;
   // Il code : newarr
 begin
   TableauDynamic:=New(TArrayDynamiqueSimple,10);
 end;

 procedure AffecteDynamiqueSetLength;
 // Il code : newarr et System.Array.Copy
 begin
   SetLength(TableauDynamic, 15); // ou 5
 end;

// ..\sscli\clr\src\bcl\system\object.cs
public class Object
{
 ...
    public static bool Equals(Object objA, Object objB) {
        if (objA==objB) {
            return true;
        }
        if (objA==null || objB==null) {
            return false;
        }
        return objA.Equals(objB);
    }

    public static bool ReferenceEquals (Object objA, Object objB) {
        return objA == objB;
    }
 ...

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ément=', 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ément=', 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ément=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 dimension  = 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 dimension  = 1
Nombre d'éléments(0) = 256
GetLowerBound(0)     = -256
GetUpperBound(0)     = -1

System.Byte[]

System.Byte[*]

type
  TArray2D = Array[,] of Integer;

var
  Y : array[,] of Integer;

type
  TArrayDynamiqueSimple = Array of Byte;
  TArrayDynamiqueMultiple = Array of Array of Byte;

var
  TableauDynamique: TArrayDynamiqueSimple;
  TableauDynamiqueMultiple : TArrayDynamiqueMultiple;
begin
  TableauDynamique := New(TArrayDynamiqueSimple, 256);
  TableauDynamiqueMultiple := New(TArrayDynamiqueMultiple, 2,2);

type
  TArray2D = Array[,] of Integer;

var
  TableauMultiple : TArray2D;
begin
   // E2307 : La fonction standard NEW s'attend à un identificateur de type de tableau dynamique.
   TableauMultiple := New(TArray2D, 1,2);

type
  TArrayDynamiqueSimple = Array of Byte;

   // Array of Array of Byte;
  TArrayDynamiqueMultiple = Array of TArrayDynamiqueSimple;

   // Array of Array of Array of Byte;
  TArrayDynamique3D = Array of TArrayDynamiqueMultiple; 

   // Array of Array of Array of Array of Byte;  
  TArrayDynamique4D = Array of TArrayDynamique3D;  

var  
  TableauDynamiqueMultiple : TArrayDynamiqueMultiple;
  TableauDynamique3 : TArrayDynamique3D;
  TableauDynamique4 : TArrayDynamique4D;
  
begin  
   // Alloue  2*2 Octets. Array[0..1][0..1]
  TableauDynamiqueMultiple := New(TArrayDynamiqueMultiple, 2,2);

   // Alloue  3*2*8 Octets. Array[0..2][0..1][0..7]
  TableauDynamique3 := New(TArrayDynamique3D,3,2,8);

   // Alloue  7*2*8*10 Octets. Array[0..6][0..1][0..7][0..9]
  TableauDynamique4 := New(TArrayDynamique4D,7,2,8,10);

  TableauDynamiqueMultiple:=TArrayDynamiqueMultiple.Create(
          TArrayDynamiqueSimple.Create(1, 2, 3, 4, 5, 9, 12, 15),
          TArrayDynamiqueSimple.Create(1, 2, 3, 4, 5, 9, 12, 15));

   // Array [0..1][0..1][0..7]
   TableauDynamique3:=TArrayDynamique3D.Create(
                          (TArrayDynamiqueMultiple.Create(
                              TArrayDynamiqueSimple.Create(1, 2, 3, 4, 5, 9, 12, 15),
                              TArrayDynamiqueSimple.Create(71, 72, 73, 74, 75, 79, 88, 85))),
                          (TArrayDynamiqueMultiple.Create(
                              TArrayDynamiqueSimple.Create(1, 2, 3, 4, 5, 9, 12, 15),
                              TArrayDynamiqueSimple.Create(71, 72, 73, 74, 75, 79, 88, 85)))
                              );

  TableauDynamique4 := TArrayDynamique4D.Create(
                        TArrayDynamique3D.Create(
                          (TArrayDynamiqueMultiple.Create(
                              TArrayDynamiqueSimple.Create(1, 2, 3, 4, 5, 9, 12, 15),
                              TArrayDynamiqueSimple.Create(71, 72, 73, 74, 75, 79, 88, 85))),
                          (TArrayDynamiqueMultiple.Create(
                              TArrayDynamiqueSimple.Create(1, 2, 3, 4, 5, 9, 12, 15),
                              TArrayDynamiqueSimple.Create(71, 72, 73, 74, 75, 79, 88, 85)))),
                        TArrayDynamique3D.Create(
                          (TArrayDynamiqueMultiple.Create(
                              TArrayDynamiqueSimple.Create(1, 2, 3, 4, 5, 9, 12, 15),
                              TArrayDynamiqueSimple.Create(71, 72, 73, 74, 75, 79, 88, 85))),
                          (TArrayDynamiqueMultiple.Create(
                              TArrayDynamiqueSimple.Create(1, 2, 3, 4, 5, 9, 12, 15),
                              TArrayDynamiqueSimple.Create(71, 72, 73, 74, 75, 79, 88, 85)))),
                              );

Const
  Nbitem=8;
   // Créé dans le constructeur de classe
  cstArray1:Array[0..Nbitem-1] of byte=(1, 2, 3, 4, 5, 9, 12, 15);
  cstArray2:Array[0..Nbitem-1] of byte=(71, 72, 73, 74, 75, 79, 88, 85);
  ...
begin  
  // Construction à privilégier pour initialiser un tableau
 TableauDynamiqueMultiple:=TArrayDynamiqueMultiple.Create(cstArray1,cstArray2);

 TableauDynamique3:=TArrayDynamique3D.Create(
                           TArrayDynamiqueMultiple.Create(cstArray1,cstArray2),
                           TArrayDynamiqueMultiple.Create(cstArray1,cstArray2));

TableauDynamiqueSimple:= New(array[] of Byte,(5, 3, 2, 4, 1, 9, 12, 15));
 TableauDynamiqueMultiple:=TArrayDynamiqueMultiple.Create(
          TableauDynamiqueSimple,
          TableauDynamiqueSimple);
  // ou mieux
 TableauDynamiqueMultiple:=TArrayDynamiqueMultiple.Create(
          New(array[] of Byte,cstArray1),
          New(array[] of Byte,cstArray1));

  SetLength(TableauDynamiqueMultiple, 2); // nombre de lignes
  SetLength(TableauDynamiqueMultiple[0], 8); // nombre de colonnes de la ligne 1
  SetLength(TableauDynamiqueMultiple[1], 8); // nombre de colonnes de la ligne 2
  
  TableauDynamiqueMultiple[0,0] := 5;
  TableauDynamiqueMultiple[0,1] := 3;
  ...
  TableauDynamiqueMultiple[0,7] := 15;
  TableauDynamiqueMultiple[1,0] := 5;
  TableauDynamiqueMultiple[1,1] := 3;
  ...
  TableauDynamiqueMultiple[1,7] := 15;
  for i:=0 to 1 do
    for j:=0 to 2 do
        writeln(TableauDynamiqueMultiple[i,j]);
  Readln;
end.

// Le code suivant est issue de la documentation de Delphi 2005.
var
  a : array [,,] of integer;  // tableau tridimensionnel
  b : array [,] of integer;   // tableau à 2 dimensions
  c : array [,] of TPoint;    // tableau à 2 dimensions de TPoint

begin
   a := New(array[3,5,7] of integer);                 // New prenant le type d'élément et la taille de chaque dimension.
                                                      // Spécifie le nombre de dimension et pas la taille réelle.

   b := New(array[,] of integer, ((1,2,3), (4,5,6))); // New prenant le type d'élément et une liste d'initialiseurs.
                                                      // Spécifie le nombre de dimension et la taille réelle.

                                                      // New prenant une liste d'initialiseurs de TPoint.
   c := New(array[,] of TPoint, (((X:1;Y:2), (X:3;Y:4)), ((X:5;Y:6), (X:7;Y:8))));
end.

type
  TArrayDynamiqueInteger = Array of Integer;
  TArray2D = Array[,] of byte;

var
  Tableau2D : TArray2D;

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

  i,j : Integer;
  N : Byte;

begin
{$R-} // Nécessaire avec les constructions suivantes, sinon erreur d'accès sur le tableau

   // Les indices débutent à zéro
  Tableau2D := New(array[,] of Byte, ((1,2,3), (4,5,6)));
  ShowInfoTableau(Tableau2D);
  For N in Tableau2D do
    Write(N);
  Writeln;

  I:=2;
  J:=3;
  // Initialisé à zéro
  Tableau2D := New(array[I,J] of Byte);
  ShowInfoTableau(Tableau2D);
  For N in Tableau2D do
    Write(N);
  Writeln;

  readln;
end.

//Projet : ..\Tableaux\LesBases31

   // Array[1..4,2..8]
  LowerBounds:= TArrayDynamiqueInteger.Create(1,2); // ici 2 dimensions. Peut être (200,1,45,5,10) = 5 dimensions
  Lengths:=TArrayDynamiqueInteger.Create(4,8);      // la taille de chaque dimension
  Tableau2D:=System.Array.CreateInstance(typeof(Byte),Lengths,LowerBounds) as TArray2D;

  Writeln('Tableau à 2 dimensions');
  ShowInfoTableau(Tableau2D);
  For N in Tableau2D do
   Write(N);
  Writeln;