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.

 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.

Des tableaux sont compatibles pour l'affectation uniquement s'ils ont le même type. Comme le langage Delphi 
utilise des équivalences de nom pour les types, le code suivant ne se compile pas :

 var
  Int1: array[1..10] of Integer;
  Int2: array[1..10] of Integer;
      ...
  Int1 := Int2;

 var Int1, Int2: array[1..10] of Integer;

 type IntArray = array[1..10] of Integer;
var
   Int1: IntArray;
   Int2: IntArray;

  TArrayStatic2D =Array[0..1,0..1] of byte;

  TArrayStatic2Dv2 = Array[0..1] of Array[0..1] of Byte;

  TArrayDynamique2D = Array of Array of Byte;

var T2D: TArrayStatic2D;
begin
  T2D[0,0]:=10;
  T2D[0][0]:=10;

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

program ConstTab;

{$APPTYPE CONSOLE}

uses
  SysUtils;

Const
 nbItem=9;
 CstTableauStatique : Array[0..nbItem] of Byte=(1, 2, 3, 4, 5, 9, 12, 15, 27, 33);

type
  TArrayDynamiqueSimple = Array of Byte;

var
  TableauDynamique : TArrayDynamiqueSimple;
  I :Byte;

begin
  {$R+}
  //{$R-}
  Writeln('CstTableauStatique[3]= ',CstTableauStatique[3]);
  //CstTableauStatique[3]:=5; // E2064 : La partie gauche n'est pas affectable
  
  Writeln('Assignation : TableauDynamique:=CstTableauStatique');
  TableauDynamique:=CstTableauStatique;
  
  Writeln('Assignation : TableauDynamique[3]:=65');
  TableauDynamique[3]:=65;
  
  Writeln('CstTableauStatique[3]= ',CstTableauStatique[3]); // = 65
  Writeln('TableauDynamique[3]= ',TableauDynamique[3]);
  
  readln;
end.

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[*]

 // Low(Simple) renvoie zéro
 For I:=Low(Simple) to High(Simple) do writeln('Simple[',I,']',simple[I]);

  // L'itérateur pointe sur une zone erronée
 For I in Simple do writeln('Simple[',I,']',simple[I]);

  //Déclenche System.IndexOutOfRangeException
 For I:=-255 to -1 do
   writeln('Simple[',I,'], writeln(Simple[I]);

 For I:=System.Array(Simple).GetLowerBound(0) to System.Array(Simple).GetUpperBound(0) do

   // Pour renseigner une valeur
   // ici le contexte nécessite un double cast
  System.Array(Simple).SetValue(TObject(Byte(I)),I);

   // Pour accéder à une valeur
  writeln('Simple[',I,']',System.Array(Simple).GetValue(I));

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 ligne
  SetLength(TableauDynamiqueMultiple[0], 8); // nombre de colonne de la ligne 1
  SetLength(TableauDynamiqueMultiple[1], 8); // nombre de colonne 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ébute à 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 dimensions
  Tableau2D:=System.Array.CreateInstance(typeof(Byte),Lengths,LowerBounds) as TArray2D;

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

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 vue 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 dimension = '+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; }
  }
 ...